const e = 'android' === wx.getSystemInfoSync().platform,
  t = `${wx.env.USER_DATA_PATH}/pag/`,
  i = wx.getFileSystemManager()
let r
try {
  r = performance.now.bind(performance)
} catch (e) {
  r = Date.now
}
class s {
  constructor() {
    ;(this.startTime = r()), (this.markers = {})
  }
  reset() {
    ;(this.startTime = r()), (this.markers = {})
  }
  mark(e) {
    e
      ? Object.keys(this.markers).find((t) => t === e)
        ? console.log(`Clock.mark(): The specified marker name '${e}' already exists!`)
        : (this.markers[e] = r())
      : console.log('Clock.mark(): An empty marker name was specified!')
  }
  measure(e, t) {
    let i, s
    if (e) {
      if (!Object.keys(this.markers).find((t) => t === e))
        return console.log(`Clock.measure(): The specified makerFrom '${e}' does not exist!`), 0
      i = this.markers[e]
    } else i = this.startTime
    if (t) {
      if (!Object.keys(this.markers).find((e) => e === t))
        return console.log(`Clock.measure(): The specified makerTo '${t}' does not exist!`), 0
      s = this.markers[t]
    } else s = r()
    return s - i
  }
}

function a(e) {
  const t = Object.getOwnPropertyNames(e.prototype).filter(
    (t) => 'constructor' !== t && 'function' == typeof e.prototype[t]
  )
  const i = (e, t) => {
    const i = e[t]
    e[t] = function (...e) {
      if (!this.destroyed) return i.call(this, ...e)
      console.error(`Don't call ${t} of the PAGView that is destroyed.`)
    }
  }
  t.forEach((t) => i(e.prototype, t))
}
const n = {
  alpha: !0,
  depth: !1,
  stencil: !1,
  antialias: !1,
}
var o = ((e) => (
    (e[(e.Normal = 0)] = 'Normal'),
    (e[(e.Multiply = 1)] = 'Multiply'),
    (e[(e.Screen = 2)] = 'Screen'),
    (e[(e.Overlay = 3)] = 'Overlay'),
    (e[(e.Darken = 4)] = 'Darken'),
    (e[(e.Lighten = 5)] = 'Lighten'),
    (e[(e.ColorDodge = 6)] = 'ColorDodge'),
    (e[(e.ColorBurn = 7)] = 'ColorBurn'),
    (e[(e.HardLight = 8)] = 'HardLight'),
    (e[(e.SoftLight = 9)] = 'SoftLight'),
    (e[(e.Difference = 10)] = 'Difference'),
    (e[(e.Exclusion = 11)] = 'Exclusion'),
    (e[(e.Hue = 12)] = 'Hue'),
    (e[(e.Saturation = 13)] = 'Saturation'),
    (e[(e.Color = 14)] = 'Color'),
    (e[(e.Luminosity = 15)] = 'Luminosity'),
    (e[(e.DestinationIn = 21)] = 'DestinationIn'),
    (e[(e.DestinationOut = 22)] = 'DestinationOut'),
    (e[(e.DestinationATop = 23)] = 'DestinationATop'),
    (e[(e.SourceIn = 24)] = 'SourceIn'),
    (e[(e.SourceOut = 25)] = 'SourceOut'),
    (e[(e.Xor = 26)] = 'Xor'),
    e
  ))(o || {}),
  h = ((e) => (
    (e[(e.None = 0)] = 'None'),
    (e[(e.Linear = 1)] = 'Linear'),
    (e[(e.Bezier = 2)] = 'Bezier'),
    (e[(e.Hold = 3)] = 'Hold'),
    e
  ))(h || {})
const l = navigator && /(ios|ipad|iphone)/.test(navigator.userAgent.toLowerCase()),
  d = (e) => {
    const t = []
    for (let i = 0; i < e.length; i++) t.push(e.charCodeAt(i))
    return t
  },
  c = (e) => [e >> 24, (e >> 16) & 255, (e >> 8) & 255, 255 & e],
  u = (e, ...t) => {
    let i = 8,
      r = t.length
    const s = r
    for (; r; ) (r -= 1), (i += t[r].byteLength)
    const a = new Uint8Array(i)
    for (
      a[0] = (i >> 24) & 255, a[1] = (i >> 16) & 255, a[2] = (i >> 8) & 255, a[3] = 255 & i, a.set(e, 4), r = 0, i = 8;
      r < s;
      ++r
    )
      a.set(t[r], i), (i += t[r].byteLength)
    return a
  }
class m {
  constructor(e) {
    this.param = e
  }
  ftyp() {
    return u(
      d('ftyp'),
      new Uint8Array(d('isom')),
      new Uint8Array([0, 0, 0, 1]),
      new Uint8Array(d('isom')),
      new Uint8Array(d('iso2')),
      new Uint8Array(d('avc1')),
      new Uint8Array(d('mp41'))
    )
  }
  moov() {
    const e = this.param.tracks.map((e) => this.trak(e)).reverse()
    return u(d('moov'), this.mvhd(), ...e, this.mvex())
  }
  moof() {
    return u(d('moof'), this.mfhd(), this.traf())
  }
  mdat() {
    const e = new Uint8Array(this.param.track.len)
    let t = 0
    return (
      this.param.videoSequence.headers.forEach((i) => {
        e.set(new Uint8Array(i.data.data()), t), (t += i.length)
      }),
      this.param.videoSequence.frames.forEach((i, r) => {
        e.set(new Uint8Array(i.fileBytes.data.data()), t), (t += i.fileBytes.length)
      }),
      u(d('mdat'), e)
    )
  }
  mvhd() {
    return u(
      d('mvhd'),
      new Uint8Array([
        0,
        0,
        0,
        0,
        ...c(2082873600),
        ...c(2082873600),
        ...c(this.param.timescale),
        ...c(this.param.duration),
        0,
        1,
        0,
        0,
        1,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        1,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        1,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        64,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        2,
      ])
    )
  }
  trak(e) {
    return u(d('trak'), this.tkhd(e), this.edts(e), this.mdia(e))
  }
  tkhd(e) {
    return u(
      d('tkhd'),
      new Uint8Array([
        0,
        0,
        0,
        1,
        ...c(2082873600),
        ...c(2082873600),
        ...c(e.id),
        0,
        0,
        0,
        0,
        ...c(e.duration),
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        1,
        0,
        0,
        0,
        0,
        1,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        1,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        64,
        0,
        0,
        0,
        (e.width >> 8) & 255,
        255 & e.width,
        0,
        0,
        (e.height >> 8) & 255,
        255 & e.height,
        0,
        0,
      ])
    )
  }
  edts(e) {
    return u(d('edts'), this.elst(e))
  }
  elst(e) {
    return u(
      d('elst'),
      new Uint8Array([
        0,
        0,
        0,
        0,
        ...c(1),
        ...c(e.duration),
        ...c(e.implicitOffset * Math.floor(e.duration / e.samples.length)),
        0,
        1,
        0,
        0,
      ])
    )
  }
  mdia(e) {
    return u(d('mdia'), this.mdhd(), this.hdlr(), this.minf(e))
  }
  mdhd() {
    return u(
      d('mdhd'),
      new Uint8Array([
        0,
        0,
        0,
        0,
        ...c(2082873600),
        ...c(2082873600),
        ...c(this.param.timescale),
        ...c(0),
        85,
        196,
        0,
        0,
      ])
    )
  }
  hdlr() {
    return u(
      d('hdlr'),
      new Uint8Array([
        0, 0, 0, 0, 0, 0, 0, 0, 118, 105, 100, 101, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 86, 105, 100, 101, 111, 72, 97,
        110, 100, 108, 101, 114, 0,
      ])
    )
  }
  minf(e) {
    return u(d('minf'), this.vmhd(), this.dinf(), this.stbl(e))
  }
  vmhd() {
    return u(d('vmhd'), new Uint8Array([0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0]))
  }
  dinf() {
    return u(d('dinf'), this.dref())
  }
  dref() {
    return u(d('dref'), new Uint8Array([0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 12, 117, 114, 108, 32, 0, 0, 0, 1]))
  }
  stbl(e) {
    return u(d('stbl'), this.stsd(e), this.stts(e), this.ctts(e), this.stss(e), this.stsc(), this.stsz(), this.stco())
  }
  stsd(e) {
    return u(d('stsd'), new Uint8Array([0, 0, 0, 0, 0, 0, 0, 1]), this.avc1(e))
  }
  avc1(e) {
    const t = [
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      1,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      (e.width >> 8) & 255,
      255 & e.width,
      (e.height >> 8) & 255,
      255 & e.height,
      0,
      72,
      0,
      0,
      0,
      72,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      1,
      18,
      98,
      105,
      110,
      101,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      24,
      255,
      255,
    ]
    return u(d('avc1'), new Uint8Array(t), this.avcc(e))
  }
  avcc(e) {
    let t = [],
      i = []
    e.sps.forEach((e) => {
      const i = e.length - 4
      t.push((i >>> 8) & 255),
        t.push(255 & i),
        (t = t.concat(Array.prototype.slice.call(new Uint8Array(e.data.data(), 4))))
    }),
      e.pps.forEach((e) => {
        const t = e.length - 4
        i.push((t >>> 8) & 255),
          i.push(255 & t),
          (i = i.concat(Array.prototype.slice.call(new Uint8Array(e.data.data(), 4))))
      })
    const r = [1, t[3], t[4], t[5], 255, 224 | e.sps.length].concat(t).concat([e.pps.length]).concat(i)
    return u(d('avcC'), new Uint8Array(r))
  }
  stts(e) {
    return u(
      d('stts'),
      new Uint8Array([0, 0, 0, 0, ...c(1), ...c(e.samples.length), ...c(Math.floor(e.duration / e.samples.length))])
    )
  }
  ctts(e) {
    const t = e.pts.length,
      i = Math.floor(e.duration / t),
      r = [0, 0, 0, 0, ...c(t)]
    for (let s = 0; s < t; s++) {
      r.push(...c(1))
      const t = s * i,
        a = (e.pts[s] + e.implicitOffset) * i
      r.push(...c(a - t))
    }
    return u(d('ctts'), new Uint8Array(r))
  }
  stss(e) {
    const t = e.samples.filter((e) => e.flags.isKeyFrame).map((e) => e.index + 1),
      i = [0, 0, 0, 0, ...c(t.length)]
    return (
      t.forEach((e) => {
        i.push(...c(e))
      }),
      u(d('stss'), new Uint8Array(i))
    )
  }
  stsc() {
    return u(d('stsc'), new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0]))
  }
  stsz() {
    return u(d('stsz'), new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))
  }
  stco() {
    return u(d('stco'), new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0]))
  }
  mvex() {
    const e = this.param.tracks.map((e) => this.trex(e)).reverse()
    return u(d('mvex'), ...e)
  }
  trex(e) {
    return u(
      d('trex'),
      new Uint8Array([
        0,
        0,
        0,
        0,
        e.id >> 24,
        (e.id >> 16) & 255,
        (e.id >> 8) & 255,
        255 & e.id,
        0,
        0,
        0,
        1,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        1,
        0,
        1,
      ])
    )
  }
  mfhd() {
    return u(
      d('mfhd'),
      new Uint8Array([
        0,
        0,
        0,
        0,
        this.param.sequenceNumber >> 24,
        (this.param.sequenceNumber >> 16) & 255,
        (this.param.sequenceNumber >> 8) & 255,
        255 & this.param.sequenceNumber,
      ])
    )
  }
  traf() {
    const e = this.sdtp()
    return (this.param.offset = e.length + 72), u(d('traf'), this.tfhd(), this.tfdt(), this.trun(), e)
  }
  tfhd() {
    return u(d('tfhd'), new Uint8Array([0, 0, 0, 0, ...c(this.param.track.id)]))
  }
  tfdt() {
    return u(d('tfdt'), new Uint8Array([0, 0, 0, 0, ...c(this.param.baseMediaDecodeTime)]))
  }
  trun() {
    const e = (this.param.track.samples || []).length,
      t = 12 + 16 * e
    this.param.offset += 8 + t
    const i = [0, 0, 15, 1, ...c(e), ...c(this.param.offset)]
    return (
      this.param.track.samples.forEach((e) => {
        const { duration: t, size: r, flags: s, cts: a } = e
        i.push(...c(t)),
          i.push(...c(r)),
          i.push((s.isLeading << 2) | s.dependsOn),
          i.push((s.isDependedOn << 6) | (s.hasRedundancy << 4) | 0 | s.isNonSync),
          i.push(61440 & s.degradPrio),
          i.push(15 & s.degradPrio),
          i.push(...c(a))
      }),
      u(d('trun'), new Uint8Array(i))
    )
  }
  sdtp() {
    const e = new Uint8Array(4 + this.param.track.samples.length)
    return (
      this.param.track.samples.forEach((t, i) => {
        e[i + 4] = (t.flags.dependsOn << 4) | (t.flags.isDependedOn << 2) | t.flags.hasRedundancy
      }),
      u(d('sdtp'), e)
    )
  }
}
const f = Object.defineProperty,
  p = Object.getOwnPropertySymbols,
  g = Object.prototype.hasOwnProperty,
  y = Object.prototype.propertyIsEnumerable,
  w = (e, t, i) =>
    t in e
      ? f(e, t, {
          enumerable: !0,
          configurable: !0,
          writable: !0,
          value: i,
        })
      : (e[t] = i),
  v = (e, t) => {
    for (var i in t || (t = {})) g.call(t, i) && w(e, i, t[i])
    if (p) for (var i of p(t)) y.call(t, i) && w(e, i, t[i])
    return e
  }
const b = (e) => {
    const t = l ? T(e) : e,
      i = S(t)
    if (!i || 0 === i.len) throw new Error('mp4Track is empty')
    const r = {
        offset: 0,
        tracks: [i],
        track: i,
        duration: i.duration,
        timescale: i.timescale,
        sequenceNumber: 1,
        baseMediaDecodeTime: 0,
        nalusBytesLen: i.len,
        videoSequence: t,
      },
      s = new m(r)
    return ((e) => {
      let t = 0
      for (const i of e) t += i.byteLength
      const i = new Uint8Array(t)
      let r = 0
      for (const t of e) i.set(t, r), (r += t.byteLength)
      return i
    })([s.ftyp(), s.moov(), s.moof(), s.mdat()])
  },
  S = (e) => {
    if (e.headers.length < 2) throw new Error('Bad header data in video sequence!')
    if (0 === e.frames.length) throw new Error('There is no frame data in the video sequence!')
    const t = {
        id: 1,
        type: 'video',
        timescale: 6e3,
        duration: Math.floor((6e3 * e.frames.length) / e.frameRate),
        width: e.getVideoWidth(),
        height: e.getVideoHeight(),
        sps: [e.headers[0]],
        pps: [e.headers[1]],
        implicitOffset: E(e.frames),
        len: 0,
        pts: [],
        samples: [],
      },
      i = e.headers.reduce((e, t) => e + t.length, 0),
      r = t.duration / e.frames.length
    return (
      e.frames.forEach((e, s) => {
        let a
        let n = null != (a = e.fileBytes.length) ? a : 0
        0 === s && (n += i),
          (t.len += n),
          t.pts.push(e.frame),
          t.samples.push({
            index: s,
            size: n,
            duration: r,
            cts: (e.frame + t.implicitOffset - s) * r,
            flags: {
              isKeyFrame: e.isKeyframe,
              isNonSync: e.isKeyframe ? 0 : 1,
              dependsOn: e.isKeyframe ? 2 : 1,
              isLeading: 0,
              isDependedOn: 0,
              hasRedundancy: 0,
              degradPrio: 0,
            },
          })
      }),
      t
    )
  },
  E = (e) => Math.max(...e.map((e, t) => t - e.frame)),
  T = (e) => {
    const t = e.frames.length
    for (let i = 0; i < e.frames.length; i++) {
      const r = v({}, e.frames[i])
      if (r.isKeyframe && i > 0) break
      ;(r.frame += t), e.frames.push(r)
    }
    return e
  },
  x = (e, t, i) => {
    const r = e.createProgram()
    if (!r) throw new Error('Failed to create program.')
    const s = R(e, t, e.VERTEX_SHADER)
    if (!s) throw new Error('Failed to create vertex shader.')
    e.attachShader(r, s)
    const a = R(e, i, e.FRAGMENT_SHADER)
    if (!a) throw new Error('Failed to create fragment shader.')
    e.attachShader(r, a), e.linkProgram(r)
    const n = e.getProgramInfoLog(r)
    n && console.log(n)
    const o = e.getShaderInfoLog(s)
    o && console.log(o)
    const h = e.getShaderInfoLog(a)
    return h && console.log(h), r
  },
  R = (e, t, i) => {
    const r = e.createShader(i)
    if (!r) throw new Error('Failed to create shader.')
    return e.shaderSource(r, t), e.compileShader(r), r
  },
  P = (e) => e.replace(/^\s+|\s+$/g, ''),
  A = (e) => {
    const t = e.createTexture()
    if (!t) throw new Error('Failed to create texture.')
    return (
      e.bindTexture(e.TEXTURE_2D, t),
      e.texParameteri(e.TEXTURE_2D, e.TEXTURE_WRAP_S, e.CLAMP_TO_EDGE),
      e.texParameteri(e.TEXTURE_2D, e.TEXTURE_WRAP_T, e.CLAMP_TO_EDGE),
      e.texParameteri(e.TEXTURE_2D, e.TEXTURE_MIN_FILTER, e.NEAREST),
      e.texParameteri(e.TEXTURE_2D, e.TEXTURE_MAG_FILTER, e.NEAREST),
      t
    )
  }
const D = {}
const k = (e, t, i, r = !1) => {
  let s
  t in D || (D[t] = []),
    null == (s = D[t]) ||
      s.push({
        node: e,
        handler: i,
        capture: r,
      }),
    e.addEventListener(t, i, r)
}
const F = Object.defineProperty,
  V = Object.getOwnPropertyDescriptor
const C = navigator && /MicroMessenger/i.test(navigator.userAgent),
  L = async (e) => {
    C &&
      window.WeixinJSBridge &&
      (await new Promise((e) => {
        window.WeixinJSBridge.invoke(
          'getNetworkType',
          {},
          () => {
            e()
          },
          () => {
            e()
          }
        )
      }))
    try {
      await e.play()
    } catch (e) {
      throw new Error(e.message)
    }
  }
let B = class {
  constructor(e) {
    ;(this.destroyed = !1),
      (this.frameRate = 0),
      (this._duration = e.frameCount / e.frameRate),
      (this.frameRate = e.frameRate)
  }
  static create(e) {
    const t = new B(e),
      i = t.load(e)
    return {
      videoReader: t,
      debugData: i,
    }
  }
  getVideoElement() {
    return this.videoElement
  }
  progress() {
    return Math.round((this.videoElement.currentTime / this._duration) * 100) / 100
  }
  duration() {
    return this._duration
  }
  currentTime() {
    return this.videoElement.currentTime || 0
  }
  start() {
    return L(this.videoElement)
  }
  pause() {
    let e
    null == (e = this.videoElement) || e.pause()
  }
  seek(e) {
    return new Promise((t) => {
      const i = () => {
        let e, r, s, a, n, o, h
        ;(e = this.videoElement),
          (s = i),
          (r = 'seeked') in D &&
            (s
              ? (null == (a = D[r]) ||
                  a
                    .filter(({ node: t, handler: i }) => t === e && i === s)
                    .forEach(({ node: e, handler: t, capture: i }) => e.removeEventListener(r, t, i)),
                (D[r] = null == (n = D[r]) ? void 0 : n.filter(({ node: t, handler: i }) => !(t === e && i === s))))
              : (null == (o = D[r]) ||
                  o
                    .filter(({ node: t }) => t === e)
                    .forEach(({ node: e, handler: t, capture: i }) => e.removeEventListener(r, t, i)),
                (D[r] = null == (h = D[r]) ? void 0 : h.filter(({ node: t }) => t !== e)))),
          t()
      }
      k(this.videoElement, 'seeked', i), (this.videoElement.currentTime = e)
    })
  }
  addListener(e, t) {
    k(this.videoElement, e, t)
  }
  removeAllListeners() {
    let e
    ;(e = this.videoElement),
      Object.keys(D).forEach((t) => {
        let i, r
        const s = t
        null == (i = D[s]) ||
          i
            .filter(({ node: t }) => t === e)
            .forEach(({ node: e, handler: t, capture: i }) => e.removeEventListener(s, t, i)),
          (D[s] = null == (r = D[s]) ? void 0 : r.filter(({ node: t }) => t !== e))
      })
  }
  getFrameData(e) {}
  clearCallback() {}
  destroy() {
    this.removeAllListeners(), (this.videoElement = void 0), (this.destroyed = !0)
  }
  load(e) {
    ;(this.videoElement = document.createElement('video')),
      (this.videoElement.style.display = 'none'),
      (this.videoElement.muted = !0),
      (this.videoElement.playsInline = !0)
    const t = new s(),
      i = b(e)
    return (
      t.mark('coverMP4'),
      (this.videoElement.src = URL.createObjectURL(
        new Blob([i], {
          type: 'video/mp4',
        })
      )),
      this.videoElement.load(),
      {
        coverMP4: t.measure('', 'coverMP4'),
      }
    )
  }
}
B = ((e, t, i, r) => {
  for (var s, a = r > 1 ? void 0 : r ? V(t, i) : t, n = e.length - 1; n >= 0; n--)
    (s = e[n]) && (a = (r ? s(t, i, a) : s(a)) || a)
  return r && a && F(t, i, a), a
})([a], B)
const _ = Object.defineProperty,
  U = Object.getOwnPropertyDescriptor
const M = (e, t) => {
  const i = new ArrayBuffer(t.data.byteLength)
  return (
    new Uint8Array(i).set(new Uint8Array(t.data)),
    {
      id: e,
      data: i,
      width: t.width,
      height: t.height,
    }
  )
}
let I = class extends B {
  constructor() {
    super(...arguments),
      (this.started = !1),
      (this.frameDataBuffers = []),
      (this.getFrameDataLooping = !1),
      (this.getFrameDataCallback = null),
      (this.getFrameDataLoopTimer = null),
      (this.currentFrame = 0),
      (this.seeking = !1)
  }
  static create(e) {
    const t = new I(e),
      i = t.load(e)
    return {
      videoReader: t,
      debugData: i,
    }
  }
  getVideoElement() {
    throw new Error('WeChat mini program does not support video element as decoder!')
  }
  progress() {
    return 0
  }
  duration() {
    return 0
  }
  currentTime() {
    return 0
  }
  async start() {
    this.started || ((this.started = !0), await this.loadedPromise, this.startGetFrameDataLoop())
  }
  pause() {}
  async seek(e) {
    let t
    const i = Math.floor(e * this.frameRate)
    if (this.frameDataBuffers.length > 0) {
      const e = this.frameDataBuffers.findIndex((e) => e.id === i)
      if (-1 !== e) return void (this.frameDataBuffers = this.frameDataBuffers.slice(e))
      this.frameDataBuffers = []
    }
    i !== this.currentFrame &&
      ((this.seeking = !0),
      await (null == (t = this.videoDecoder) ? void 0 : t.seek(e)),
      (this.seeking = !1),
      (this.currentFrame = i))
  }
  getFrameData(e) {
    if (
      (this.frameDataBuffers.length <= 2 && !this.getFrameDataLooping && this.startGetFrameDataLoop(),
      0 === this.frameDataBuffers.length)
    )
      return void (this.getFrameDataCallback = e)
    const t = this.frameDataBuffers.shift()
    t ? e(t) : (this.getFrameDataCallback = e)
  }
  addListener(e, t) {
    let i
    const r = e
    null == (i = this.videoDecoder) || i.on(r, t)
  }
  removeAllListeners() {}
  destroy() {
    let e
    this.clearFrameDataLoop(),
      this.clearCallback(),
      null == (e = this.videoDecoder) || e.remove(),
      (this.videoDecoder = void 0),
      this.mp4Path &&
        ((e) => {
          try {
            i.accessSync(e), i.unlinkSync(e)
          } catch (e) {
            console.error(e)
          }
        })(this.mp4Path),
      (this.destroyed = !0)
  }
  clearCallback() {
    this.getFrameDataCallback = null
  }
  load(e) {
    const r = new s()
    ;(this.mp4Path = `${t}${Date.now()}.mp4`),
      ((e) => {
        try {
          i.accessSync(e)
        } catch (t) {
          try {
            i.mkdirSync(e)
          } catch (e) {
            console.error(t)
          }
        }
      })(t),
      r.mark('createDir')
    const a = b(e)
    return (
      r.mark('coverMP4'),
      ((e, t) => {
        try {
          i.writeFileSync(e, t, 'utf8')
        } catch (e) {
          throw new Error(e)
        }
      })(this.mp4Path, a.buffer),
      r.mark('writeFile'),
      (this.videoDecoder = wx.createVideoDecoder()),
      r.mark('createDecoder'),
      (this.loadedPromise = this.videoDecoder.start({
        source: this.mp4Path,
        mode: 1,
      })),
      this.videoDecoder.on('ended', () => {
        let e
        null == (e = this.videoDecoder) ||
          e.seek(0).then(() => {
            this.currentFrame = 0
          })
      }),
      {
        createDir: r.measure('', 'createDir'),
        coverMP4: r.measure('createDir', 'coverMP4'),
        writeFile: r.measure('coverMP4', 'writeFile'),
        createDecoder: r.measure('writeFile', 'createDecoder'),
      }
    )
  }
  startGetFrameDataLoop() {
    ;(this.getFrameDataLooping = !0),
      (this.getFrameDataLoopTimer = setInterval(() => {
        this.getFrameDataLoop()
      }, 2))
  }
  getFrameDataLoop() {
    if (this.seeking) return
    if (!this.videoDecoder) throw (this.clearFrameDataLoop(), new Error('VideoDecoder is not ready!'))
    if (this.frameDataBuffers.length >= 6) return (this.getFrameDataLooping = !1), void this.clearFrameDataLoop()
    const e = this.videoDecoder.getFrameData()
    null !== e &&
      (this.getFrameDataCallback
        ? (this.getFrameDataCallback(M(this.currentFrame, e)), (this.getFrameDataCallback = null))
        : this.frameDataBuffers.push(M(this.currentFrame, e)),
      (this.currentFrame += 1))
  }
  clearFrameDataLoop() {
    this.getFrameDataLoopTimer && (clearInterval(this.getFrameDataLoopTimer), (this.getFrameDataLoopTimer = null)),
      (this.getFrameDataLooping = !1)
  }
}
I = ((e, t, i, r) => {
  for (var s, a = r > 1 ? void 0 : r ? U(t, i) : t, n = e.length - 1; n >= 0; n--)
    (s = e[n]) && (a = (r ? s(t, i, a) : s(a)) || a)
  return r && a && _(t, i, a), a
})([a], I)
var O = ((e) => ((e.Canvas2D = '2d'), (e.WebGL = 'WebGL'), e))(O || {}),
  q = ((e) => (
    (e.onAnimationStart = 'onAnimationStart'),
    (e.onAnimationEnd = 'onAnimationEnd'),
    (e.onAnimationCancel = 'onAnimationCancel'),
    (e.onAnimationRepeat = 'onAnimationRepeat'),
    (e.onAnimationUpdate = 'onAnimationUpdate'),
    (e.onAnimationPlay = 'onAnimationPlay'),
    (e.onAnimationPause = 'onAnimationPause'),
    e
  ))(q || {}),
  G = ((e) => ((e.None = 'None'), (e.Stretch = 'Stretch'), (e.LetterBox = 'LetterBox'), (e.Zoom = 'Zoom'), e))(G || {}),
  N = Object.freeze({
    __proto__: null,
    RenderingMode: O,
    EventName: q,
    ScaleMode: G,
  })
const z =
  '\n      attribute vec2 a_position;\n      attribute vec2 a_texCoord;\n      \n      uniform vec2 u_resolution;\n      uniform vec2 u_scale;\n      \n      varying vec2 v_texCoord;\n    \n      \n      void main() {\n         // convert the rectangle from pixels to 0.0 to 1.0\n         vec2 zeroToOne = a_position / u_resolution;\n      \n         // convert from 0->1 to 0->2\n         vec2 zeroToTwo = zeroToOne * 2.0;\n      \n         // convert from 0->2 to -1->+1 (clipspace)\n         vec2 clipSpace = zeroToTwo - 1.0;\n      \n         gl_Position = vec4(clipSpace * vec2(1, -1), 0, 1);\n      \n         // pass the texCoord to the fragment shader\n         // The GPU will interpolate this value between points.\n         v_texCoord = a_texCoord / u_scale;\n      }\n        '
class W {
  constructor() {
    this.listenersMap = {}
  }
  on(e, t) {
    void 0 === this.listenersMap[e] && (this.listenersMap[e] = []), this.listenersMap[e].push(t)
  }
  off(e, t) {
    const i = this.listenersMap[e]
    if (void 0 === i) return
    if (void 0 === t) return void delete this.listenersMap[e]
    const r = i.findIndex((e) => e === t)
    i.splice(r, 1)
  }
  emit(e, ...t) {
    const i = this.listenersMap[e]
    if (void 0 === i || i.length < 1) return !1
    for (const e of i) e(...t)
    return !0
  }
}
const X = Object.defineProperty,
  H = Object.getOwnPropertyDescriptor,
  j = Object.getOwnPropertySymbols,
  K = Object.prototype.hasOwnProperty,
  Y = Object.prototype.propertyIsEnumerable,
  $ = (e, t, i) =>
    t in e
      ? X(e, t, {
          enumerable: !0,
          configurable: !0,
          writable: !0,
          value: i,
        })
      : (e[t] = i),
  Z = (e, t) => {
    for (var i in t || (t = {})) K.call(t, i) && $(e, i, t[i])
    if (j) for (var i of j(t)) Y.call(t, i) && $(e, i, t[i])
    return e
  }
let J = class {
  constructor(e, t, i) {
    ;(this.canvasSize = {
      width: 0,
      height: 0,
    }),
      (this.playing = !1),
      (this.viewportSize = {
        x: 0,
        y: 0,
        width: 0,
        height: 0,
        scaleX: 1,
        scaleY: 1,
      }),
      (this.destroyed = !1),
      (this.renderTimer = null),
      (this.repeatCount = 0),
      (this.viewScaleMode = G.LetterBox),
      (this.debugData = {
        FPS: 0,
        decodePAGFile: 0,
        createDir: 0,
        coverMP4: 0,
        writeFile: 0,
        createDecoder: 0,
        getFrame: 0,
        draw: 0,
      })
    const r = e.getVideoSequence()
    if (!r) throw new Error('PAGFile has no BMP video sequence!')
    delete r.composition,
      (this.videoSequence = r),
      (this.canvas = t),
      (this.videoParam = ((e, t) => ({
        width: e.mainComposition.width,
        height: e.mainComposition.height,
        hasAlpha: t.alphaStartX > 0 || t.alphaStartY > 0,
        alphaStartX: t.alphaStartX,
        alphaStartY: t.alphaStartY,
        sequenceWidth: t.width,
        sequenceHeight: t.height,
        MP4Width: (t.width + t.alphaStartX) % 2 == 0 ? t.width + t.alphaStartX : t.width + t.alphaStartX + 1,
        MP4Height: (t.height + t.alphaStartY) % 2 == 0 ? t.height + t.alphaStartY : t.height + t.alphaStartY + 1,
      }))(e, r)),
      (this.eventManager = new W()),
      (this.renderingMode = i.renderingMode || O.WebGL),
      this.updateSize(i.useScale),
      this.setScaleMode()
  }
  isPlaying() {
    return this.playing
  }
  isDestroyed() {
    return this.destroyed
  }
  duration() {
    return this.videoSequence.frameCount / this.videoSequence.frameRate
  }
  frameRate() {
    return this.videoSequence.frameRate
  }
  setRepeatCount(e = 1) {
    this.repeatCount = e < 0 ? -1 : e - 1
  }
  addListener(e, t) {
    return this.eventManager.on(e, t)
  }
  removeListener(e, t) {
    return this.eventManager.off(e, t)
  }
  scaleMode() {
    return this.viewScaleMode
  }
  setScaleMode(e = G.LetterBox) {
    switch (((this.viewScaleMode = e), e)) {
      case G.None:
        this.viewportSize = {
          x: 0,
          y: this.renderingMode === O.WebGL ? this.canvas.height - this.videoParam.height : 0,
          width: this.videoParam.width,
          height: this.videoParam.height,
          scaleX: 1,
          scaleY: 1,
        }
        break
      case G.Stretch:
        this.viewportSize = {
          x: 0,
          y: 0,
          width: this.canvas.width,
          height: this.canvas.height,
          scaleX: this.canvas.width / this.videoParam.sequenceWidth,
          scaleY: this.canvas.height / this.videoParam.sequenceHeight,
        }
        break
      case G.LetterBox:
        {
          const e = this.canvas.width / this.videoParam.sequenceWidth,
            t = this.canvas.height / this.videoParam.sequenceHeight,
            i = Math.min(e, t)
          this.viewportSize = {
            x: (this.canvas.width - this.videoParam.sequenceWidth * i) / 2,
            y: (this.canvas.height - this.videoParam.sequenceHeight * i) / 2,
            width: this.videoParam.sequenceWidth * i,
            height: this.videoParam.sequenceHeight * i,
            scaleX: i,
            scaleY: i,
          }
        }
        break
      case G.Zoom: {
        const e = this.canvas.width / this.videoParam.sequenceWidth,
          t = this.canvas.height / this.videoParam.sequenceHeight,
          i = Math.max(e, t)
        this.viewportSize = {
          x: (this.canvas.width - this.videoParam.sequenceWidth * i) / 2,
          y: (this.canvas.height - this.videoParam.sequenceHeight * i) / 2,
          width: this.videoParam.sequenceWidth * i,
          height: this.videoParam.sequenceHeight * i,
          scaleX: i,
          scaleY: i,
        }
      }
    }
  }
  updateSize(e = !0) {
    if (!this.canvas) throw new Error('Canvas element is not found!')
    let t
    const i = getComputedStyle(this.canvas),
      r = {
        width: Number(i.width.replace('px', '')),
        height: Number(i.height.replace('px', '')),
      }
    if (r.width > 0 && r.height > 0) t = r
    else {
      const e = {
        width: Number(this.canvas.style.width.replace('px', '')),
        height: Number(this.canvas.style.height.replace('px', '')),
      }
      t =
        e.width > 0 && e.height > 0
          ? e
          : {
              width: this.canvas.width,
              height: this.canvas.height,
            }
    }
    if (!e)
      return (
        (this.canvas.width = this.canvas.width || t.width), void (this.canvas.height = this.canvas.height || t.height)
      )
    ;(this.canvas.style.width = `${t.width}px`),
      (this.canvas.style.height = `${t.height}px`),
      (this.canvas.width = t.width * window.devicePixelRatio),
      (this.canvas.height = t.height * window.devicePixelRatio)
  }
  getDebugData() {
    return this.debugData
  }
  setDebugData(e) {
    this.debugData = Z(Z({}, this.debugData), e)
  }
  loadContext() {}
  clearRender() {}
}
J = ((e, t, i, r) => {
  for (var s, a = r > 1 ? void 0 : r ? H(t, i) : t, n = e.length - 1; n >= 0; n--)
    (s = e[n]) && (a = (r ? s(t, i, a) : s(a)) || a)
  return r && a && X(t, i, a), a
})([a], J)
const Q = Object.defineProperty,
  ee = Object.getOwnPropertyDescriptor
navigator && /MicroMessenger/i.test(navigator.userAgent)
let te = class extends J {
  constructor(e, t, i) {
    super(e, t, i),
      (this.fpsBuffer = []),
      (this.currentFrame = -1),
      (this.needSeek = !1),
      (this.videoReader = this.createVideoReader(this.videoSequence))
  }
  async play() {
    this.playing ||
      ((this.playing = !0),
      await this.videoReader.start(),
      await this.flushLoop(),
      0 === this.getProgress() && this.eventManager.emit(q.onAnimationStart),
      this.eventManager.emit(q.onAnimationPlay))
  }
  pause() {
    this.playing &&
      (this.videoReader.pause(), this.clearTimer(), (this.playing = !1), this.eventManager.emit(q.onAnimationPause))
  }
  stop() {
    this.videoReader.pause(),
      this.videoReader.seek(0),
      this.clearRender(),
      (this.playing = !1),
      this.eventManager.emit(q.onAnimationCancel)
  }
  destroy() {
    this.clearTimer(), this.clearRender(), (this.canvas = null), this.videoReader.destroy(), (this.destroyed = !0)
  }
  getProgress() {
    return this.currentFrame / this.videoSequence.frameCount
  }
  setProgress(e) {
    if (e < 0 || e > 1) throw new Error('progress must be between 0.0 and 1.0!')
    const t = Math.round(e * this.videoSequence.frameCount)
    this.currentFrame !== t && ((this.needSeek = !0), (this.currentFrame = t))
  }
  flush() {
    return this.flushInternal(!0)
  }
  draw() {}
  createVideoReader(e) {
    const { videoReader: t, debugData: i } = B.create(e)
    return (
      this.setDebugData(i),
      l ||
        t.addListener('ended', () => {
          this.repeat()
        }),
      t
    )
  }
  async repeat() {
    return 0 === this.repeatCount
      ? (this.setProgress(1),
        await this.flushInternal(!0),
        this.videoReader.pause(),
        this.clearTimer(),
        (this.playing = !1),
        this.eventManager.emit('onAnimationEnd'),
        !1)
      : ((this.repeatCount -= 1),
        l ? await this.videoReader.seek(0) : this.videoReader.start(),
        this.eventManager.emit('onAnimationRepeat'),
        !0)
  }
  flushLoop() {
    return (
      (this.renderTimer = window.requestAnimationFrame(() => {
        this.flushLoop()
      })),
      l && this.duration() - this.videoReader.currentTime() <= 1 / this.frameRate() && this.repeat(),
      this.flushInternal(!1)
    )
  }
  clearTimer() {
    this.renderTimer && (window.cancelAnimationFrame(this.renderTimer), (this.renderTimer = null))
  }
  updateFPS() {
    let e
    try {
      e = performance.now()
    } catch (t) {
      e = Date.now()
    }
    ;(this.fpsBuffer = this.fpsBuffer.filter((t) => e - t <= 1e3)),
      this.fpsBuffer.push(e),
      this.setDebugData({
        FPS: this.fpsBuffer.length,
      })
  }
  async flushInternal(e) {
    const t = new s()
    this.needSeek
      ? (e
          ? await this.videoReader.seek(this.currentFrame / this.frameRate())
          : this.videoReader.seek(this.currentFrame / this.frameRate()),
        (this.needSeek = !1))
      : (this.currentFrame = Math.floor(this.videoReader.currentTime() * this.frameRate())),
      this.draw(),
      t.mark('draw'),
      this.setDebugData({
        draw: t.measure('', 'draw'),
      }),
      this.updateFPS(),
      this.eventManager.emit(q.onAnimationUpdate)
  }
}
te = ((e, t, i, r) => {
  for (var s, a = r > 1 ? void 0 : r ? ee(t, i) : t, n = e.length - 1; n >= 0; n--)
    (s = e[n]) && (a = (r ? s(t, i, a) : s(a)) || a)
  return r && a && Q(t, i, a), a
})([a], te)
const ie = Object.defineProperty,
  re = Object.getOwnPropertyDescriptor,
  se = Object.getOwnPropertySymbols,
  ae = Object.prototype.hasOwnProperty,
  ne = Object.prototype.propertyIsEnumerable,
  oe = (e, t, i) =>
    t in e
      ? ie(e, t, {
          enumerable: !0,
          configurable: !0,
          writable: !0,
          value: i,
        })
      : (e[t] = i)
let he = class extends te {
  constructor(e, t, i) {
    let r
    super(e, t, i),
      (this.scale = {
        x: 1,
        y: 1,
      }),
      (this.positionLocation = 0),
      (this.texcoordLocation = 0),
      (this.alphaStartLocation = null),
      (this.scaleLocation = null),
      (this.resolutionLocation = null),
      (this.positionBuffer = null),
      (this.texcoordBuffer = null),
      (this.originalVideoTexture = null),
      (this.renderingTexture = null),
      (this.renderingFbo = null)
    const s =
      null == (r = this.canvas)
        ? void 0
        : r.getContext(
            'webgl',
            ((e, t) => {
              for (var i in t || (t = {})) ae.call(t, i) && oe(e, i, t[i])
              if (se) for (var i of se(t)) ne.call(t, i) && oe(e, i, t[i])
              return e
            })({}, n)
          )
    if (!s) throw new Error("Can't get WebGL context!")
    ;(this.gl = s),
      this.videoParam.hasAlpha
        ? (this.program = x(
            this.gl,
            P(z),
            P(
              '\n      precision mediump float;\n      // our texture\n      uniform sampler2D u_image;\n      \n      // the texCoords passed in from the vertex shader.\n      varying vec2 v_texCoord;\n      uniform vec2 v_alphaStart;\n      \n      void main() {\n         vec4 color = texture2D(u_image, v_texCoord);\n         vec4 alpha = texture2D(u_image, vec2(v_texCoord.x + v_alphaStart.x, v_texCoord.y + v_alphaStart.y));\n         gl_FragColor = vec4(color.rgb * alpha.r, alpha.r);\n      }     \n         '
            )
          ))
        : (this.program = x(
            this.gl,
            P(z),
            P(
              '\n      precision mediump float;\n      // our texture\n      uniform sampler2D u_image;\n      \n      // the texCoords passed in from the vertex shader.\n      varying vec2 v_texCoord;\n      \n      void main() {\n         gl_FragColor = texture2D(u_image, v_texCoord);\n      }\n         '
            )
          )),
      this.loadContext()
  }
  loadContext() {
    if (!this.program) throw new Error('program is not initialized')
    if (((this.positionLocation = this.gl.getAttribLocation(this.program, 'a_position')), -1 === this.positionLocation))
      throw new Error('unable to get attribute location for a_position')
    if (((this.scaleLocation = this.gl.getUniformLocation(this.program, 'u_scale')), -1 === this.scaleLocation))
      throw new Error('unable to get attribute location for u_scale')
    if (((this.texcoordLocation = this.gl.getAttribLocation(this.program, 'a_texCoord')), -1 === this.texcoordLocation))
      throw new Error('unable to get attribute location for a_texCoord')
    if (
      this.videoParam.hasAlpha &&
      ((this.alphaStartLocation = this.gl.getUniformLocation(this.program, 'v_alphaStart')), !this.alphaStartLocation)
    )
      throw new Error('unable to get attribute location for v_alphaStart')
    if (
      ((this.resolutionLocation = this.gl.getUniformLocation(this.program, 'u_resolution')),
      -1 === this.positionLocation)
    )
      throw new Error('unable to get attribute location for u_resolution')
    if (
      ((this.positionBuffer = this.gl.createBuffer()),
      this.gl.bindBuffer(this.gl.ARRAY_BUFFER, this.positionBuffer),
      this.setRectangle(this.gl, 0, 0, this.videoParam.MP4Width, this.videoParam.MP4Height),
      (this.texcoordBuffer = this.gl.createBuffer()),
      this.gl.bindBuffer(this.gl.ARRAY_BUFFER, this.texcoordBuffer),
      this.gl.bufferData(
        this.gl.ARRAY_BUFFER,
        new Float32Array([0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1]),
        this.gl.STATIC_DRAW
      ),
      (this.renderingTexture = A(this.gl)),
      this.gl.texImage2D(
        this.gl.TEXTURE_2D,
        0,
        this.gl.RGBA,
        this.videoParam.sequenceWidth,
        this.videoParam.sequenceHeight,
        0,
        this.gl.RGBA,
        this.gl.UNSIGNED_BYTE,
        null
      ),
      (this.renderingFbo = this.gl.createFramebuffer()),
      !this.renderingFbo)
    )
      throw new Error('unable to create framebuffer')
    this.gl.bindFramebuffer(this.gl.FRAMEBUFFER, this.renderingFbo),
      this.gl.framebufferTexture2D(
        this.gl.FRAMEBUFFER,
        this.gl.COLOR_ATTACHMENT0,
        this.gl.TEXTURE_2D,
        this.renderingTexture,
        0
      ),
      (this.originalVideoTexture = A(this.gl))
  }
  draw() {
    this.gl.bindTexture(this.gl.TEXTURE_2D, this.originalVideoTexture),
      this.texImage2D(),
      this.gl.clearColor(0, 0, 0, 0),
      this.gl.clear(this.gl.COLOR_BUFFER_BIT),
      this.gl.useProgram(this.program),
      this.gl.enableVertexAttribArray(this.positionLocation),
      this.gl.bindBuffer(this.gl.ARRAY_BUFFER, this.positionBuffer)
    const e = this.gl.FLOAT
    this.gl.vertexAttribPointer(this.positionLocation, 2, e, false, 0, 0),
      this.gl.enableVertexAttribArray(this.texcoordLocation),
      this.gl.bindBuffer(this.gl.ARRAY_BUFFER, this.texcoordBuffer),
      this.gl.vertexAttribPointer(this.texcoordLocation, 2, e, false, 0, 0),
      this.videoParam.hasAlpha &&
        this.gl.uniform2f(
          this.alphaStartLocation,
          this.videoParam.alphaStartX / this.videoParam.MP4Width / this.scale.x,
          this.videoParam.alphaStartY / this.videoParam.MP4Height / this.scale.y
        ),
      this.gl.bindTexture(this.gl.TEXTURE_2D, this.originalVideoTexture),
      this.gl.bindFramebuffer(this.gl.FRAMEBUFFER, this.renderingFbo),
      this.gl.uniform2f(this.resolutionLocation, this.videoParam.sequenceWidth, this.videoParam.sequenceHeight),
      this.gl.uniform2f(this.scaleLocation, this.scale.x, this.scale.y),
      this.gl.viewport(0, 0, this.videoParam.sequenceWidth, this.videoParam.sequenceHeight)
    const t = this.gl.TRIANGLES
    this.gl.drawArrays(t, 0, 6),
      this.gl.bindFramebuffer(this.gl.FRAMEBUFFER, null),
      this.gl.uniform2f(this.resolutionLocation, this.videoParam.sequenceWidth, this.videoParam.sequenceHeight),
      this.gl.viewport(this.viewportSize.x, this.viewportSize.y, this.viewportSize.width, this.viewportSize.height),
      this.gl.drawArrays(t, 0, 6)
  }
  clearRender() {
    this.gl.clearColor(0, 0, 0, 0), this.gl.clear(this.gl.COLOR_BUFFER_BIT)
  }
  detectWebGLContext() {
    return (() => {
      const e = document.createElement('canvas')
      return !(!e.getContext('webgl') && !e.getContext('experimental-webgl'))
    })()
  }
  texImage2D() {
    this.gl.texImage2D(
      this.gl.TEXTURE_2D,
      0,
      this.gl.RGBA,
      this.gl.RGBA,
      this.gl.UNSIGNED_BYTE,
      this.videoReader.getVideoElement()
    )
  }
  setRectangle(e, t, i, r, s) {
    const a = t,
      n = t + r,
      o = i,
      h = i + s
    e.bufferData(e.ARRAY_BUFFER, new Float32Array([a, o, n, o, a, h, a, h, n, o, n, h]), e.STATIC_DRAW)
  }
}
he = ((e, t, i, r) => {
  for (var s, a = r > 1 ? void 0 : r ? re(t, i) : t, n = e.length - 1; n >= 0; n--)
    (s = e[n]) && (a = (r ? s(t, i, a) : s(a)) || a)
  return r && a && ie(t, i, a), a
})([a], he)
var le = ((e) => (
    (e[(e.Unknown = 0)] = 'Unknown'),
    (e[(e.Vector = 1)] = 'Vector'),
    (e[(e.Bitmap = 2)] = 'Bitmap'),
    (e[(e.Video = 3)] = 'Video'),
    e
  ))(le || {}),
  de = ((e) => (
    (e[(e.End = 0)] = 'End'),
    (e[(e.FontTables = 1)] = 'FontTables'),
    (e[(e.VectorCompositionBlock = 2)] = 'VectorCompositionBlock'),
    (e[(e.CompositionAttributes = 3)] = 'CompositionAttributes'),
    (e[(e.ImageTables = 4)] = 'ImageTables'),
    (e[(e.LayerBlock = 5)] = 'LayerBlock'),
    (e[(e.LayerAttributes = 6)] = 'LayerAttributes'),
    (e[(e.SolidColor = 7)] = 'SolidColor'),
    (e[(e.TextSource = 8)] = 'TextSource'),
    (e[(e.TextPathOption = 9)] = 'TextPathOption'),
    (e[(e.TextMoreOption = 10)] = 'TextMoreOption'),
    (e[(e.ImageReference = 11)] = 'ImageReference'),
    (e[(e.CompositionReference = 12)] = 'CompositionReference'),
    (e[(e.Transform2D = 13)] = 'Transform2D'),
    (e[(e.MaskBlock = 14)] = 'MaskBlock'),
    (e[(e.ShapeGroup = 15)] = 'ShapeGroup'),
    (e[(e.Rectangle = 16)] = 'Rectangle'),
    (e[(e.Ellipse = 17)] = 'Ellipse'),
    (e[(e.PolyStar = 18)] = 'PolyStar'),
    (e[(e.ShapePath = 19)] = 'ShapePath'),
    (e[(e.Fill = 20)] = 'Fill'),
    (e[(e.Stroke = 21)] = 'Stroke'),
    (e[(e.GradientFill = 22)] = 'GradientFill'),
    (e[(e.GradientStroke = 23)] = 'GradientStroke'),
    (e[(e.MergePaths = 24)] = 'MergePaths'),
    (e[(e.TrimPaths = 25)] = 'TrimPaths'),
    (e[(e.Repeater = 26)] = 'Repeater'),
    (e[(e.RoundCorners = 27)] = 'RoundCorners'),
    (e[(e.Performance = 28)] = 'Performance'),
    (e[(e.DropShadowStyle = 29)] = 'DropShadowStyle'),
    (e[(e.InnerShadowStyle = 30)] = 'InnerShadowStyle'),
    (e[(e.OuterGlowStyle = 31)] = 'OuterGlowStyle'),
    (e[(e.InnerGlowStyle = 32)] = 'InnerGlowStyle'),
    (e[(e.BevelAndEmbossStyle = 33)] = 'BevelAndEmbossStyle'),
    (e[(e.SatinStyle = 34)] = 'SatinStyle'),
    (e[(e.ColorOverlayStyle = 35)] = 'ColorOverlayStyle'),
    (e[(e.GradientOverlayStyle = 36)] = 'GradientOverlayStyle'),
    (e[(e.StrokeStyle = 37)] = 'StrokeStyle'),
    (e[(e.TintEffect = 38)] = 'TintEffect'),
    (e[(e.FillEffect = 39)] = 'FillEffect'),
    (e[(e.StrokeEffect = 40)] = 'StrokeEffect'),
    (e[(e.TritoneEffect = 41)] = 'TritoneEffect'),
    (e[(e.DropShadowEffect = 42)] = 'DropShadowEffect'),
    (e[(e.RadialWipeEffect = 43)] = 'RadialWipeEffect'),
    (e[(e.DisplacementMapEffect = 44)] = 'DisplacementMapEffect'),
    (e[(e.BitmapCompositionBlock = 45)] = 'BitmapCompositionBlock'),
    (e[(e.BitmapSequence = 46)] = 'BitmapSequence'),
    (e[(e.ImageBytes = 47)] = 'ImageBytes'),
    (e[(e.ImageBytes2 = 48)] = 'ImageBytes2'),
    (e[(e.ImageBytes3 = 49)] = 'ImageBytes3'),
    (e[(e.VideoCompositionBlock = 50)] = 'VideoCompositionBlock'),
    (e[(e.VideoSequence = 51)] = 'VideoSequence'),
    (e[(e.LayerAttributesV2 = 52)] = 'LayerAttributesV2'),
    (e[(e.Count = 53)] = 'Count'),
    e
  ))(de || {})
const ce = (e) => {
  const t = e.readUint16()
  let i = (63 & t) >>> 0
  const r = t >> 6
  return (
    63 === i && (i = e.readUint32()),
    e.context.tagLevel < r && (e.context.tagLevel = r),
    {
      code: r,
      length: i,
    }
  )
}

function ue(e, t, i) {
  let r = ce(e)
  for (; r.code !== de.End; ) {
    const s = e.readBytes(r.length)
    i(s, r.code, t), e.context.tagLevel < s.context.tagLevel && (e.context.tagLevel = s.context.tagLevel), (r = ce(e))
  }
}
const me = {
    red: 0,
    green: 0,
    blue: 0,
  },
  fe = {
    red: 255,
    green: 255,
    blue: 255,
  },
  pe = () => {
    console.error('PAG Verify Failed!')
  },
  ge = (e) => !!e || (console.error('PAG Verify Failed!'), !1),
  ye = class {
    constructor() {
      ;(this.id = 0),
        (this.width = 0),
        (this.height = 0),
        (this.duration = 0),
        (this.frameRate = 30),
        (this.backgroundColor = fe),
        (this.cacheID = 0),
        (this.cacheID = ye.cacheIDCount),
        (ye.cacheIDCount += 1)
    }
    type() {
      return le.Unknown
    }
    getStaticTimeRanges() {
      return []
    }
    verify() {
      return ge(this.width > 0 && this.height > 0 && this.duration > 0 && this.frameRate > 0)
    }
  }
const we = ye
we.cacheIDCount = 1
class ve extends we {
  constructor() {
    super(...arguments),
      (this.hasAlpha = !1),
      (this.sequences = []),
      (this.staticTimeRanges = []),
      (this.staticTimeRangeUpdated = !1)
  }
  type() {
    return le.Video
  }
  getStaticTimeRanges() {
    return (
      this.staticTimeRangeUpdated || ((this.staticTimeRangeUpdated = !0), this.updateStaticTimeRanges()),
      this.staticTimeRanges
    )
  }
  updateStaticTimeRanges() {
    if (!(this.duration <= 1))
      if (this.sequences.length > 0) {
        let e = this.sequences[0]
        for (let t = 1; t < this.sequences.length; t++) {
          const i = this.sequences[t]
          i.frameRate > e.frameRate && (e = i)
        }
        const t = this.frameRate / e.frameRate
        for (const i of e.staticTimeRanges)
          (i.start = Math.round(i.start * t)), (i.end = Math.round(i.end * t)), this.staticTimeRanges.push(i)
      } else {
        const e = {
          start: 0,
          end: this.duration - 1,
        }
        this.staticTimeRanges.push(e)
      }
  }
  hasImageContent() {
    return !0
  }
  verify() {
    if (!super.verify() || this.sequences.length <= 0) return pe(), !1
    for (const e of this.sequences) if (!e || !e.verify()) return pe(), !1
    return !0
  }
}
class be {
  constructor(e, t) {
    ;(this.numerator = 1), (this.denominator = 1), (this.numerator = e), (this.denominator = t)
  }
  value() {
    return this.numerator / this.denominator
  }
}
const Se = new be(1, 1)
class Ee {
  constructor(e, t) {
    ;(this.x = e), (this.y = t)
  }
}
const Te = new Ee(0, 0)
var xe = ((e) => (
    (e[(e.None = 0)] = 'None'),
    (e[(e.Alpha = 1)] = 'Alpha'),
    (e[(e.AlphaInverted = 2)] = 'AlphaInverted'),
    (e[(e.Luma = 3)] = 'Luma'),
    (e[(e.LumaInverted = 4)] = 'LumaInverted'),
    e
  ))(xe || {}),
  Re = ((e) => (
    (e[(e.Unknown = 0)] = 'Unknown'),
    (e[(e[void 0] = 1)] = 'undefined'),
    (e[(e.Solid = 2)] = 'Solid'),
    (e[(e.Text = 3)] = 'Text'),
    (e[(e.Shape = 4)] = 'Shape'),
    (e[(e.Image = 5)] = 'Image'),
    (e[(e.PreCompose = 6)] = 'PreCompose'),
    e
  ))(Re || {})
class Pe {
  constructor() {
    ;(this.id = 0),
      (this.parent = void 0),
      (this.containingComposition = void 0),
      (this.stretch = Se),
      (this.startTime = 0),
      (this.duration = 0),
      (this.autoOrientation = !1),
      (this.transform = void 0),
      (this.isActive = !0),
      (this.blendMode = o.Normal),
      (this.trackMatteType = 0),
      (this.trackMatteLayer = void 0),
      (this.timeRemap = void 0),
      (this.masks = void 0),
      (this.effects = void 0),
      (this.layerStyles = void 0),
      (this.layerCache = void 0),
      (this.maxScale = void 0)
  }
  type() {
    return 0
  }
  excludeVaryingRanges(e) {
    let t
    if (
      (null == (t = this.transform) || t.excludeVaryingRanges(e),
      void 0 !== this.timeRemap && this.timeRemap.excludeVaryingRanges(e),
      void 0 !== this.masks)
    )
      for (const t of this.masks) t.excludeVaryingRanges(e)
    if (void 0 !== this.effects && this.effects.length > 0) for (const t of this.effects) t.excludeVaryingRanges(e)
    if (void 0 !== this.layerStyles && this.layerStyles.length > 0)
      for (const t of this.layerStyles) t.excludeVaryingRanges(e)
  }
  gotoFrame(e) {
    let t
    if (
      (null == (t = this.transform) || t.gotoFrame(e),
      void 0 !== this.timeRemap && this.timeRemap.gotoFrame(e),
      void 0 !== this.masks && this.masks.length > 0)
    )
      for (const t of this.masks) t.gotoFrame(e)
    if (void 0 !== this.effects && this.effects.length > 0) for (const t of this.effects) t.gotoFrame(e)
    if (void 0 !== this.layerStyles && this.layerStyles.length > 0) for (const t of this.layerStyles) t.gotoFrame(e)
  }
  verify() {
    if (!this.containingComposition || this.duration <= 0 || !this.transform) return pe(), !1
    if (!this.transform.verify()) return pe(), !1
    if (this.masks && this.masks.length > 0) for (const e of this.masks) if (!e || !e.verify()) return pe(), !1
    if (this.layerStyles && this.layerStyles.length > 0)
      for (const e of this.layerStyles) if (!e || !e.verify()) return pe(), !1
    if (this.effects && this.effects.length > 0) for (const e of this.effects) if (!e || !e.verify()) return pe(), !1
    return !0
  }
  getMaxScaleFactor() {
    if (void 0 !== this.maxScale) return this.maxScale
    this.maxScale = new Ee(1, 1)
    const e = this.transform.scale
    if (e.animatable()) {
      const { keyframes: t } = e
      let i = Math.abs(t[0].startValue.x),
        r = Math.abs(t[0].startValue.y)
      if (void 0 !== t && t.length > 0)
        for (const e of t) {
          const t = Math.abs(e.endValue.x),
            s = Math.abs(e.endValue.y)
          i < t && (i = t), r < s && (r = s)
        }
      ;(this.maxScale.x = i), (this.maxScale.y = r)
    } else (this.maxScale.x = Math.abs(e.value.x)), (this.maxScale.y = Math.abs(e.value.y))
    if (void 0 !== this.parent) {
      const e = this.parent.getMaxScaleFactor()
      ;(this.maxScale.x *= e.x), (this.maxScale.y *= e.y)
    }
    return this.maxScale
  }
}
const Ae = (e) => ({
    red: e.readUint8(),
    green: e.readUint8(),
    blue: e.readUint8(),
  }),
  De = (e) => e.readEncodedUint64(),
  ke = (e) => {
    const t = e.readFloat32(),
      i = e.readFloat32()
    return new Ee(t, i)
  },
  Fe = (e, t) => {
    ;(t.width = e.readEncodeInt32()),
      (t.height = e.readEncodeInt32()),
      (t.duration = De(e)),
      (t.frameRate = e.readFloat32()),
      (t.backgroundColor = Ae(e))
  }
class Ve {
  constructor() {
    ;(this.tagLevel = 0), (this.compositions = []), (this.errorMessages = [])
  }
  throwException(e) {
    this.errorMessages.push(e)
  }
  releaseCompositions() {
    const e = this.compositions.slice()
    return (this.compositions = []), e
  }
}
const Ce = 'PAG file decode error!'
class Le {
  constructor(e, t) {
    ;(this._position = 0),
      (this.bitPosition = 0),
      (this.dataView = new DataView(e)),
      (this.littleEndian = !!t),
      (this.context = new Ve())
  }
  get length() {
    return this.dataView.byteLength
  }
  get bytesAvailable() {
    return this.dataView.byteLength - this._position
  }
  data() {
    return this.dataView.buffer
  }
  get position() {
    return this._position
  }
  alignWithBytes() {
    this.bitPosition = 8 * this._position
  }
  readBoolean() {
    const e = this.dataView.getInt8(this._position)
    return (this._position += 1), this.positonChanged(), Boolean(e)
  }
  readChar() {
    if (this._position >= this.length) throw new Error(Ce)
    const e = this.dataView.getInt8(this._position)
    return (this._position += 1), this.positonChanged(), String.fromCharCode(e)
  }
  readUint8() {
    if (this._position >= this.length) throw new Error(Ce)
    const e = this.dataView.getUint8(this._position)
    return (this._position += 1), this.positonChanged(), e
  }
  readInt8() {
    if (this._position >= this.length) throw new Error(Ce)
    const e = this.dataView.getInt8(this._position)
    return (this._position += 1), this.positonChanged(), e
  }
  readInt16() {
    if (this._position >= this.length - 1) throw new Error(Ce)
    const e = this.dataView.getInt16(this._position, this.littleEndian)
    return (this._position += 2), this.positonChanged(), e
  }
  readUint16() {
    if (this._position >= this.length - 1) throw new Error(Ce)
    const e = this.dataView.getUint16(this._position, this.littleEndian)
    return (this._position += 2), this.positonChanged(), e
  }
  readInt24() {
    if (this._position >= this.length - 2) throw new Error(Ce)
    const e = this.dataView.getInt16(this._position, this.littleEndian),
      t = this.dataView.getInt8(this._position + 2)
    return (this._position += 3), this.positonChanged(), this.littleEndian ? e + 65536 * t : 65536 * e + t
  }
  readUint24() {
    if (this._position >= this.length - 2) throw new Error(Ce)
    const e = this.dataView.getUint16(this._position, this.littleEndian),
      t = this.dataView.getUint8(this._position + 2)
    return (this._position += 3), this.positonChanged(), this.littleEndian ? e + 65536 * t : 65536 * e + t
  }
  readInt32() {
    if (this._position >= this.length - 3) throw new Error(Ce)
    const e = this.dataView.getInt32(this._position, this.littleEndian)
    return (this._position += 4), this.positonChanged(), e
  }
  readUint32() {
    if (this._position >= this.length - 3) throw new Error(Ce)
    const e = this.dataView.getUint32(this._position, this.littleEndian)
    return (this._position += 4), this.positonChanged(), e
  }
  readInt64() {
    if (this._position >= this.length - 7) throw new Error(Ce)
    const e = this.dataView.getInt32(this._position, this.littleEndian),
      t = this.dataView.getInt32(this._position + 4, this.littleEndian)
    return (this._position += 8), this.positonChanged(), this.littleEndian ? e + 2 ** 32 * t : 2 ** 32 * e + t
  }
  readUint64() {
    if (this._position >= this.length - 7) throw new Error(Ce)
    const e = this.dataView.getUint32(this._position, this.littleEndian),
      t = this.dataView.getUint32(this._position + 4, this.littleEndian)
    return (this._position += 8), this.positonChanged(), this.littleEndian ? e + 2 ** 32 * t : 2 ** 32 * e + t
  }
  readFloat32() {
    if (this._position >= this.length - 3) throw new Error(Ce)
    const e = this.dataView.getFloat32(this._position, this.littleEndian)
    return (this._position += 4), this.positonChanged(), e
  }
  readDouble() {
    if (this._position >= this.length - 7) throw new Error(Ce)
    const e = this.dataView.getFloat64(this._position, this.littleEndian)
    return (this._position += 8), this.positonChanged(), e
  }
  readUTF8String() {
    if (this._position >= this.length) throw new Error(Ce)
    let e = '',
      t = 0
    for (let i = this._position; i < this.length && 0 !== this.dataView.getUint8(i); i++)
      (e += `%${this.dataView.getUint8(i).toString(16)}`), (t += 1)
    return (this._position += t), this.positonChanged(), decodeURIComponent(e)
  }
  readEncodedUint32() {
    let e = 0,
      t = 0
    for (let i = 0; i < 32; i += 7) {
      if (this._position >= this.length) throw Error('readEncodedUint32 End of file was encountered.')
      if (((t = this.dataView.getUint8(this._position)), (this._position += 1), (e |= (127 & t) << i), 0 == (128 & t)))
        break
    }
    return this.positonChanged(), e
  }
  readEncodeInt32() {
    const e = this.readEncodedUint32(),
      t = e >> 1
    return (1 & e) > 0 ? -t : t
  }
  readEncodedUint64() {
    let e = 0,
      t = 0
    for (let i = 0; i < 64; i += 7) {
      if (this._position >= this.length) throw Error('readEncodedUint64 End of file was encountered.')
      if (((t = this.dataView.getUint8(this._position)), (this._position += 1), (e |= (127 & t) << i), 0 == (128 & t)))
        break
    }
    return this.positonChanged(), e
  }
  readEncodeInt64() {
    const e = this.readEncodedUint64(),
      t = e << 0
    return (1 & e) > 0 ? -t : t
  }
  readBytes(e) {
    const t = e || this.length - this._position
    if (this._position > this.length - t) throw new Error(Ce)
    const i = this.dataView.buffer.slice(this._position, this._position + t)
    return (this._position += t), this.positonChanged(), new Le(i, this.littleEndian)
  }
  readUBits(e) {
    const t = [0, 1, 3, 7, 15, 31, 63, 127, 255]
    let i = 0
    if (this.bitPosition > 8 * this.length - e) throw new Error(Ce)
    let r = 0
    for (; r < e; ) {
      const s = Math.floor(0.125 * this.bitPosition),
        a = this.bitPosition % 8
      let n = this.dataView.getUint8(s) >> a
      const o = Math.min(8 - a, e - r)
      ;(n &= t[o]), (i |= n << r), (r += o), (this.bitPosition += o)
    }
    return this.bitPositionChanged(), i
  }
  readBits(e) {
    let t = this.readUBits(e)
    t <<= 32 - e
    return (t << 0) >> (32 - e)
  }
  readNumBits() {
    return this.readUBits(5) + 1
  }
  readInt32List(e) {
    const t = this.readNumBits(),
      i = new Array(e)
    for (let r = 0; r < e; r++) i[r] = this.readBits(t)
    return i
  }
  readUint32List(e) {
    const t = this.readNumBits(),
      i = new Array(e)
    for (let r = 0; r < e; r++) i[r] = this.readUBits(t)
    return i
  }
  readBitBoolean() {
    return 0 !== this.readUBits(1)
  }
  readFloatList(e, t) {
    const i = this.readNumBits(),
      r = new Array(e)
    for (let s = 0; s < e; s++) r[s] = this.readBits(i) * t
    return r
  }
  bitPositionChanged() {
    this._position = Math.ceil(0.125 * this.bitPosition)
  }
  positonChanged() {
    this.bitPosition = 8 * this._position
  }
}
class Be {
  constructor(e, t) {
    ;(this.length = 0), (this.data = e), (this.length = t)
  }
}
class _e {
  constructor() {
    ;(this.isKeyframe = !1), (this.frame = 0), (this.fileBytes = new Be(new Le(new ArrayBuffer(0)), 0))
  }
}
class Ue extends class {
  constructor() {
    ;(this.composition = void 0),
      (this.id = 0),
      (this.width = 0),
      (this.height = 0),
      (this.frameRate = 0),
      (this.frameCount = 0),
      (this.isKeyFrameFlags = [])
  }
  verify() {
    return ge(void 0 !== this.composition && this.width > 0 && this.height > 0 && this.frameRate > 0)
  }
} {
  constructor() {
    super(...arguments),
      (this.alphaStartX = 0),
      (this.alphaStartY = 0),
      (this.frames = []),
      (this.headers = []),
      (this.staticTimeRanges = [])
  }
  verify() {
    if (!super.verify() || this.frames.length <= 0) return pe(), !1
    for (const e of this.frames) if (!e || !e.fileBytes) return pe(), !1
    for (const e of this.headers) if (!e) return pe(), !1
    return !0
  }
  getVideoWidth() {
    let e = this.alphaStartX + this.width
    return e % 2 == 1 && (e += 1), e
  }
  getVideoHeight() {
    let e = this.alphaStartY + this.height
    return e % 2 == 1 && (e += 1), e
  }
}
const Me = (e) => {
    const t = e.readEncodedUint32(),
      i = e.readBytes(t)
    if (0 === t) throw new Error('Read start code with length 0!')
    const r = new ArrayBuffer(t + 4)
    return (
      new DataView(r).setUint32(0, t),
      ((e, t, i, r, s) => {
        if (t >= e.byteLength || r >= i.byteLength || i.byteLength - r > e.byteLength - t || s > i.byteLength) return
        const a = new Uint8Array(e),
          n = new Uint8Array(i, r, s)
        a.set(n, t)
      })(r, 4, i.data(), 0, t),
      new Be(new Le(r), t + 4)
    )
  },
  Ie = (e, t, i) => {
    const { composition: r } = i
    switch (t) {
      case de.CompositionAttributes:
        Fe(e, r)
        break
      case de.VideoSequence: {
        const t = ((e, t) => {
          const i = new Ue()
          ;(i.width = e.readEncodeInt32()),
            (i.height = e.readEncodeInt32()),
            (i.frameRate = e.readFloat32()),
            t && ((i.alphaStartX = e.readEncodeInt32()), (i.alphaStartY = e.readEncodeInt32()))
          const r = Me(e),
            s = Me(e)
          i.headers.push(r, s), (i.frameCount = e.readEncodedUint32())
          for (let t = 0; t < i.frameCount; t++) {
            const t = new _e()
            ;(t.isKeyframe = e.readBitBoolean()), i.frames.push(t)
          }
          for (let t = 0; t < i.frameCount; t++) {
            const r = i.frames[t]
            ;(r.frame = De(e)), (r.fileBytes = Me(e))
          }
          if (e.bytesAvailable > 0) {
            const t = e.readEncodedUint32()
            for (let r = 0; r < t; r++) {
              const t = {
                start: 0,
                end: 0,
              }
              ;(t.start = De(e)), (t.end = De(e)), i.staticTimeRanges.push(t)
            }
          }
          return i
        })(e, i.hasAlpha)
        ;(t.composition = r), r.sequences.push(t)
        break
      }
    }
  }
var Oe = ((e) => (
  (e[(e.Unknown = 0)] = 'Unknown'),
  (e[(e.Tint = 1)] = 'Tint'),
  (e[(e.Fill = 2)] = 'Fill'),
  (e[(e.Stroke = 3)] = 'Stroke'),
  (e[(e.Tritone = 4)] = 'Tritone'),
  (e[(e.DropShadow = 5)] = 'DropShadow'),
  (e[(e.RadialWipe = 6)] = 'RadialWipe'),
  (e[(e.DisplacementMap = 7)] = 'DisplacementMap'),
  e
))(Oe || {})

function qe(e, t, i) {
  if (i < t) return
  for (let r = e.length - 1; r >= 0; r--) {
    const s = e[r]
    if (!(s.end < t || s.start > i)) {
      if (s.start < t && s.end > i) {
        const a = {
          start: i + 1,
          end: s.end,
        }
        ;(s.end = t - 1), a.end > a.start && e.splice(r + 1, 0, a), s.end <= s.start && e.splice(r, 1)
        break
      }
      s.start >= t && s.end <= i
        ? e.splice(r, 1)
        : s.start < t
        ? ((s.end = t - 1), s.end <= s.start && e.splice(r, 1))
        : ((s.start = i + 1), s.end <= s.start && e.splice(r, 1))
    }
  }
}

function Ge(e, t) {
  for (let i = e.length - 1; i >= 0; i--) {
    const r = e[i]
    if (r.start === t || r.end <= t) break
    if (r.start < t && r.end > t) {
      const s = {
        start: t,
        end: r.end,
      }
      ;(r.end = t - 1), s.end > s.start && e.splice(i + 1, 0, s), r.end <= r.start && e.splice(i, 1)
      break
    }
  }
}
class Ne extends we {
  constructor() {
    super(...arguments), (this.layers = []), (this.staticTimeRanges = []), (this.staticTimeRangeUpdated = !1)
  }
  type() {
    return le.Vector
  }
  getStaticTimeRanges() {
    return (
      this.staticTimeRangeUpdated || ((this.staticTimeRangeUpdated = !0), this.updateStaticTimeRanges()),
      this.staticTimeRanges
    )
  }
  verify() {
    if (!super.verify()) return pe(), !1
    for (const e of this.layers) if (!e || !e.verify()) return pe(), !1
    return !0
  }
  updateStaticTimeRanges() {
    if (this.duration > 1) {
      const e = {
        start: 0,
        end: this.duration - 1,
      }
      this.staticTimeRanges = [e]
      for (const e of this.layers) {
        if (this.staticTimeRanges.length <= 0) break
        e.excludeVaryingRanges(this.staticTimeRanges),
          Ge(this.staticTimeRanges, e.startTime),
          Ge(this.staticTimeRanges, e.startTime + e.duration)
      }
    }
  }
}
class ze {
  constructor(e) {
    this.value = e
  }
  animatable() {
    return !1
  }
  excludeVaryingRanges(e) {}
  gotoFrame(e) {}
}
class We {
  static createDefaultTransform2D() {
    return new We()
  }
  constructor() {
    ;(this.anchorPoint = new ze(Te)),
      (this.position = new ze(Te)),
      (this.xPosition = new ze(0)),
      (this.yPosition = new ze(0)),
      (this.scale = new ze(new Ee(1, 1))),
      (this.rotation = new ze(0)),
      (this.opacity = new ze(255))
  }
  excludeVaryingRanges(e) {
    this.anchorPoint.excludeVaryingRanges(e),
      void 0 !== this.position
        ? this.position.excludeVaryingRanges(e)
        : (this.xPosition.excludeVaryingRanges(e), this.yPosition.excludeVaryingRanges(e)),
      this.scale.excludeVaryingRanges(e),
      this.rotation.excludeVaryingRanges(e),
      this.opacity.excludeVaryingRanges(e)
  }
  gotoFrame(e) {
    this.anchorPoint.gotoFrame(e),
      void 0 !== this.position
        ? this.position.gotoFrame(e)
        : (this.xPosition.gotoFrame(e), this.yPosition.gotoFrame(e)),
      this.scale.gotoFrame(e),
      this.rotation.gotoFrame(e),
      this.opacity.gotoFrame(e)
  }
  verify() {
    return (
      void 0 !== this.anchorPoint &&
      (void 0 !== this.position || (void 0 !== this.xPosition && void 0 !== this.yPosition)) &&
      void 0 !== this.scale &&
      void 0 !== this.rotation &&
      void 0 !== this.opacity
    )
  }
}
class Xe extends Pe {
  constructor() {
    super(...arguments),
      (this.composition = void 0),
      (this.compositionStartTime = 0),
      (this.staticTimeRanges = void 0),
      (this.staticTimeRangeUpdated = !1)
  }
  static wrap(e) {
    const t = new Xe()
    t.duration = e.duration
    const i = new We()
    return (t.transform = i), (t.composition = e), t
  }
  type() {
    return Re.PreCompose
  }
  excludeVaryingRanges(e) {
    super.excludeVaryingRanges(e), e && 0 !== e.length && this.updateStaticTimeRanges()
  }
  gotoFrame(e) {
    super.gotoFrame(e)
  }
  verify() {
    return !!super.verify() && !!this.composition
  }
  updateStaticTimeRanges() {
    let e
    if (this.staticTimeRangeUpdated) return
    this.staticTimeRangeUpdated = !0
    const t = null == (e = this.composition) ? void 0 : e.getStaticTimeRanges()
    if (t) {
      for (let e = t.length - 1; e >= 0; e--) {
        const i = t[e]
        ;(i.start += this.compositionStartTime),
          (i.end += this.compositionStartTime),
          i.end <= this.startTime
            ? t.pop()
            : i.start < this.startTime
            ? (i.start = 0)
            : i.start >= this.startTime + this.duration - 1
            ? t.pop()
            : i.end > this.startTime + this.duration - 1 && (i.end = this.startTime + this.duration - 1)
      }
      this.staticTimeRanges = t
    }
  }
}
class He extends Pe {
  constructor() {
    super(...arguments), (this.contents = [])
  }
  type() {
    return Re.Shape
  }
  excludeVaryingRanges(e) {
    super.excludeVaryingRanges(e)
    for (const t of this.contents) t.excludeVaryingRanges(e)
  }
  gotoFrame(e) {
    super.gotoFrame(e)
    for (const t of this.contents) t.gotoFrame(e)
  }
  verify() {
    if (!super.verify()) return !1
    for (const e of this.contents) if (void 0 === e || !e.verify()) return !1
    return !0
  }
}
class je extends Pe {
  constructor() {
    super(...arguments), (this.solidColor = me), (this.width = 0), (this.height = 0)
  }
  type() {
    return Re.Solid
  }
  excludeVaryingRanges(e) {
    super.excludeVaryingRanges(e)
  }
  gotoFrame(e) {
    super.gotoFrame(e)
  }
  verify() {
    return super.verify() ? ge(this.width > 0 && this.height > 0) : (pe(), !1)
  }
}
class Ke extends Pe {
  type() {
    return Re.undefined
  }
}
class Ye {
  constructor() {
    ;(this.startTime = 0),
      (this.endTime = 0),
      (this.interpolationType = h.Hold),
      (this.bezierOut = []),
      (this.bezierIn = []),
      (this.spatialOut = Te),
      (this.spatialIn = Te)
  }
  initialize() {}
  getValue(e) {
    return this.startValue
  }
  containsTime(e) {
    return e >= this.startTime && e < this.endTime
  }
}
class $e extends ze {
  constructor(e) {
    if (!e || 0 === e.length) throw new Error('keyframes is required')
    if (void 0 === e[0].startValue) throw new Error('startValue is required')
    super(e[0].startValue), (this.keyframes = e), (this.lastKeyframeIndex = 0)
    for (const t of e) t.initialize()
  }
  animatable() {
    return !0
  }
  excludeVaryingRanges(e) {
    for (const t of this.keyframes)
      switch (t.interpolationType) {
        case h.Bezier:
        case h.Linear:
          qe(e, t.startTime, t.endTime - 1)
          break
        default:
          Ge(e, t.startTime), Ge(e, t.endTime)
      }
  }
  gotoFrame(e) {
    let t = this.keyframes[this.lastKeyframeIndex]
    if (t.containsTime(e)) this.value = t.getValue(e)
    else {
      if (e < t.startTime)
        for (
          ;
          this.lastKeyframeIndex > 0 &&
          ((this.lastKeyframeIndex -= 1), !this.keyframes[this.lastKeyframeIndex].containsTime(e));

        );
      else
        for (
          ;
          this.lastKeyframeIndex < this.keyframes.length - 1 &&
          ((this.lastKeyframeIndex += 1), !this.keyframes[this.lastKeyframeIndex].containsTime(e));

        );
      ;(t = this.keyframes[this.lastKeyframeIndex]),
        void 0 !== t.startValue && e <= t.startTime
          ? (this.value = t.startValue)
          : void 0 !== t.endValue && e >= t.endTime
          ? (this.value = t.endValue)
          : (this.value = t.getValue(e))
    }
  }
}
var Ze = ((e) => (
  (e[(e.Value = 0)] = 'Value'),
  (e[(e.FixedValue = 1)] = 'FixedValue'),
  (e[(e.SimpleProperty = 2)] = 'SimpleProperty'),
  (e[(e.DiscreteProperty = 3)] = 'DiscreteProperty'),
  (e[(e.MultiDimensionProperty = 4)] = 'MultiDimensionProperty'),
  (e[(e.SpatialProperty = 5)] = 'SpatialProperty'),
  (e[(e.BitFlag = 6)] = 'BitFlag'),
  (e[(e.Custom = 7)] = 'Custom'),
  e
))(Ze || {})
const Je = (e, t, i) => {
  const r = i,
    s = []
  if (!r.configs || 0 === r.configs.length) return t
  for (const t of r.configs) {
    const i = rt(e, t)
    s.push(i)
  }
  e.alignWithBytes()
  let a = 0
  for (const i of r.configs) {
    const r = s[a],
      n = i.key
    i.readAttribute(e, r, t, n), (a += 1)
  }
  return t
}
class Qe {
  constructor(e, t, i) {
    ;(this.attributeType = t), (this.defaultValue = i), (this.key = e)
  }
  readAttribute(e, t, i, r) {}
  readValue(e) {}
  readValueList(e, t, i) {}
  dimensionality() {
    return 1
  }
  newKeyframe(e) {
    return new Ye()
  }
}
const et = (e, t, i, r, s) => {
    6 === s.attributeType
      ? (i[r] = t.exist)
      : 1 === s.attributeType
      ? (i[r] = s.readValue(e))
      : 0 === s.attributeType
      ? (i[r] = it(e, s, t))
      : (i[r] = tt(e, s, t))
  },
  tt = (e, t, i) => {
    let r
    if (i.exist)
      if (i.animatable) {
        const s = st(e, t, i)
        if (!s || 0 === s.length) throw new Error('Wrong number of keyframes!')
        at(e, s, t), nt(e, s, t), i.hasSpatial, (r = new $e(s))
      } else r = new ze(it(e, t, i))
    else r = new ze(t.defaultValue)
    return r
  },
  it = (e, t, i) => (i.exist ? t.readValue(e) : t.defaultValue),
  rt = (e, t) => {
    const i = {
        exist: !1,
        animatable: !1,
        hasSpatial: !1,
      },
      { attributeType: r } = t
    return 1 === r
      ? ((i.exist = !0), i)
      : ((i.exist = e.readBitBoolean()),
        i.exist && 0 !== r && 6 !== r && 7 !== r
          ? ((i.animatable = e.readBitBoolean()),
            i.animatable && 5 === r ? ((i.hasSpatial = e.readBitBoolean()), i) : i)
          : i)
  },
  st = (e, t, i) => {
    const r = [],
      s = e.readEncodedUint32()
    for (let a = 0; a < s; a++) {
      let s
      if (3 === t.attributeType) s = new Ye()
      else {
        const r = e.readUBits(2)
        r === h.Hold ? (s = new Ye()) : ((s = t.newKeyframe(i)), (s.interpolationType = r))
      }
      r.push(s)
    }
    return r
  },
  at = (e, t, i) => {
    const r = t.length
    t[0].startTime = De(e)
    for (let i = 0; i < r; i++) {
      const s = De(e)
      ;(t[i].endTime = s), i < r - 1 && (t[i + 1].startTime = s)
    }
    const s = []
    i.readValueList(e, s, r + 1)
    let a = 0
    ;(t[0].startValue = s[a]), (a += 1)
    for (let e = 0; e < r; e++) {
      const i = s[a]
      ;(a += 1), (t[e].endValue = i), e < r - 1 && (t[e + 1].startValue = i)
    }
  },
  nt = (e, t, i) => {
    const r = 4 === i.attributeType ? i.dimensionality() : 1,
      s = e.readNumBits()
    for (const i of t) {
      if (i.interpolationType !== h.Bezier) continue
      let t, a
      for (let n = 0; n < r; n++)
        (t = 0.005 * e.readBits(s)),
          (a = 0.005 * e.readBits(s)),
          i.bezierOut.push({
            x: t,
            y: a,
          }),
          (t = 0.005 * e.readBits(s)),
          (a = 0.005 * e.readBits(s)),
          i.bezierIn.push({
            x: t,
            y: a,
          })
    }
  }

function ot(e, t, i) {
  return e + (t - e) * i
}
class ht {
  getInterpolation(e) {
    return e
  }
}
class lt extends Ye {
  initialize() {
    super.initialize(),
      this.interpolationType === h.Bezier || ((this.xInterpolator = new ht()), (this.yInterpolator = new ht()))
  }
  getValue(e) {
    let t, i, r, s
    const a = (e - this.startTime) / (this.endTime - this.startTime),
      n = null != (i = null == (t = this.xInterpolator) ? void 0 : t.getInterpolation(a)) ? i : a,
      o = null != (s = null == (r = this.yInterpolator) ? void 0 : r.getInterpolation(a)) ? s : a
    return {
      x: ot(this.startValue.x, this.endValue.x, n),
      y: ot(this.startValue.y, this.endValue.y, o),
    }
  }
}
class dt extends Ye {
  initialize() {
    this.interpolationType === h.Bezier || (this.interpolator = new ht())
  }
  getProgress(e) {
    let t, i
    const r = (e - this.startTime) / (this.endTime - this.startTime)
    return null != (i = null == (t = this.interpolator) ? void 0 : t.getInterpolation(r)) ? i : r
  }
  getValue(e) {
    const t = this.getProgress(e)
    return ot(this.startValue, this.endValue, t)
  }
}
class ct extends Qe {
  constructor(e, t, i) {
    super(e, t, i)
  }
  readAttribute(e, t, i, r) {
    et(e, t, i, r, this)
  }
  readValue(e) {
    return e.readFloat32()
  }
  readValueList(e, t, i) {
    for (let r = 0; r < i; r++) t.push(this.readValue(e))
  }
  dimensionality() {
    return 1
  }
  newKeyframe(e) {
    return new dt()
  }
}
class ut extends Qe {
  constructor(e, t, i) {
    super(e, t, i)
  }
  readAttribute(e, t, i, r) {
    et(e, t, i, r, this)
  }
  readValue(e) {
    return e.readBoolean()
  }
  readValueList(e, t, i) {
    for (let r = 0; r < i; r++) t.push(e.readBitBoolean())
  }
  dimensionality() {
    return 1
  }
  newKeyframe(e) {
    return new Ye()
  }
}
class mt extends Qe {
  constructor(e, t, i) {
    super(e, t, i)
  }
  readAttribute(e, t, i, r) {
    et(e, t, i, r, this)
  }
  readValue(e) {
    return e.readUint8()
  }
  readValueList(e, t, i) {
    const r = e.readUint32List(i)
    for (let e = 0; e < i; e++) t.push(r[e])
  }
  dimensionality() {
    return 1
  }
  newKeyframe(e) {
    return new dt()
  }
}
class ft extends Qe {
  constructor(e, t, i) {
    super(e, t, i)
  }
  readAttribute(e, t, i, r) {
    et(e, t, i, r, this)
  }
  readValue(e) {
    return De(e)
  }
  readValueList(e, t, i) {
    for (let r = 0; r < i; r++) t[r] = this.readValue(e)
  }
  dimensionality() {
    return 1
  }
  newKeyframe(e) {
    return new dt()
  }
}
class pt extends Qe {
  constructor(e, t, i) {
    super(e, t, i)
  }
  readAttribute(e, t, i, r) {
    et(e, t, i, r, this)
  }
  readValue(e) {
    return ke(e)
  }
  readValueList(e, t, i) {
    if (this.attributeType === Ze.SpatialProperty) {
      const r = e.readFloatList(2 * i, 0.05)
      for (let e = 0; e < i; e++) t[e] || (t[e] = new Ee(0, 0)), (t[e].x = r[e])
    } else for (let r = 0; r < i; r++) t[r] = ke(e)
  }
  dimensionality() {
    return 2
  }
  newKeyframe(e) {
    return this.attributeType === Ze.MultiDimensionProperty ? new lt() : new dt()
  }
}
class gt extends Qe {
  constructor(e, t, i) {
    super(e, t, i)
  }
  readAttribute(e, t, i, r) {
    et(e, t, i, r, this)
  }
  readValue(e) {
    return ((e) => {
      const t = e.readEncodeInt32(),
        i = e.readEncodedUint32()
      return new be(t, i)
    })(e)
  }
  readValueList(e, t, i) {
    for (let r = 0; r < i; r++) t[r] = this.readValue(e)
  }
  dimensionality() {
    return 1
  }
  newKeyframe(e) {
    return new dt()
  }
}
class yt extends Qe {
  constructor(e, t, i) {
    super(e, t, i)
  }
  readAttribute(e, t, i, r) {
    et(e, t, i, r, this)
  }
  readValue(e) {
    return ((e) => {
      const t = e.readEncodedUint32()
      if (0 === t) throw new Error('Layer ID is 0')
      const i = new Pe()
      return (i.id = t), i
    })(e)
  }
  readValueList(e, t, i) {
    for (let r = 0; r < i; r++) t[r] = this.readValue(e)
  }
  dimensionality() {
    return 1
  }
  newKeyframe(e) {
    return new dt()
  }
}
const wt = {
    tagCode: de.LayerAttributes,
    configs: [
      new ut('isActive', Ze.BitFlag, !0),
      new ut('autoOrientation', Ze.BitFlag, !1),
      new yt('parent', Ze.Value, void 0),
      new gt('stretch', Ze.Value, Se),
      new ft('startTime', Ze.Value, 0),
      new mt('blendMode', Ze.Value, o.Normal),
      new mt('trackMatteType', Ze.Value, xe.None),
      new ct('timeRemap', Ze.SimpleProperty, 0),
      new ft('duration', Ze.FixedValue, 0),
    ],
  },
  vt = {
    tagCode: de.LayerAttributesV2,
    configs: [
      new ut('isActive', Ze.BitFlag, !0),
      new ut('autoOrientation', Ze.BitFlag, !1),
      new yt('parent', Ze.Value, void 0),
      new gt('stretch', Ze.Value, Se),
      new ft('startTime', Ze.Value, 0),
      new mt('blendMode', Ze.Value, o.Normal),
      new mt('trackMatteType', Ze.Value, xe.None),
      new ct('timeRemap', Ze.SimpleProperty, 0),
      new ft('duration', Ze.FixedValue, 0),
      new (class extends Qe {
        constructor(e, t, i) {
          super(e, t, i)
        }
        readAttribute(e, t, i, r) {
          et(e, t, i, r, this)
        }
        readValue(e) {
          return e.readUTF8String()
        }
        readValueList(e, t, i) {
          for (let r = 0; r < i; r++) t[r] = this.readValue(e)
        }
        dimensionality() {
          return 1
        }
        newKeyframe(e) {
          return new dt()
        }
      })('name', Ze.Value, ''),
    ],
  },
  bt = {
    tagCode: de.Transform2D,
    configs: [
      new pt('anchorPoint', Ze.SpatialProperty, Te),
      new pt('position', Ze.SpatialProperty, Te),
      new ct('xPosition', Ze.SimpleProperty, 0),
      new ct('yPosition', Ze.SimpleProperty, 0),
      new pt('scale', Ze.MultiDimensionProperty, new Ee(1, 1)),
      new ct('rotation', Ze.SimpleProperty, 0),
      new mt('opacity', Ze.SimpleProperty, 255),
    ],
  }
de.MaskBlock
const St = (e, t, i) => {
    switch (t) {
      case de.LayerAttributes:
        Je(e, i, wt), i.duration <= 0 && (i.duration = 1)
        break
      case de.LayerAttributesV2:
        Je(e, i, vt), i.duration <= 0 && (i.duration = 1)
        break
      case de.Transform2D:
        ;(i.transform = new We()),
          Je(e, i.transform, bt),
          i.transform.position.animatable() ||
          i.transform.position.value !== Te ||
          (!i.transform.xPosition.animatable() &&
            0 === i.transform.xPosition.value &&
            !i.transform.yPosition.animatable() &&
            0 === i.transform.yPosition.value)
            ? ((i.transform.xPosition = new ze(0)), (i.transform.yPosition = new ze(0)))
            : (i.transform.position = new ze(Te))
        break
      case de.SolidColor:
        i.type() === Re.Solid &&
          (function (e, t) {
            ;(t.solidColor = Ae(e)), (t.width = e.readEncodeInt32()), (t.height = e.readEncodeInt32())
          })(e, i)
        break
      case de.CompositionReference:
        i.type() === Re.PreCompose &&
          (function (e, t) {
            const i = e.readEncodedUint32()
            i > 0 && ((t.composition = new we()), (t.composition.id = i)), (t.compositionStartTime = De(e))
          })(e, i)
    }
  },
  Et = (e, t, i) => {
    switch (t) {
      case de.CompositionAttributes:
        Fe(e, i)
        break
      case de.LayerBlock:
        i.layers.push(
          ((e) => {
            let t
            switch (e.readUint8()) {
              case Re.undefined:
                t = new Ke()
                break
              case Re.Solid:
                t = new je()
                break
              case Re.Shape:
                t = new He()
                break
              case Re.PreCompose:
                t = new Xe()
                break
              default:
                t = new Pe()
            }
            return (t.id = e.readEncodedUint32()), ue(e, t, St), t
          })(e)
        )
    }
  },
  Tt = (e) => {
    if (e && 0 === e.length) return
    const t = new Map()
    for (const i of e) i && (xt(i), t.set(i.id, i))
    let i = 0
    for (const r of e)
      if (r) {
        if (void 0 !== r.parent) {
          const e = r.parent.id,
            i = t.get(e)
          void 0 !== i && (r.parent = i)
        }
        if (
          (i > 0 && Rt(r.trackMatteType) && (r.trackMatteLayer = e[i - 1]),
          void 0 !== r.effects && r.effects.length > 0)
        )
          for (const e of r.effects) e && (e.type(), Oe.DisplacementMap)
        i += 1
      }
  },
  xt = (e) => {
    let t
    if (!e || !e.masks || 0 === e.masks.length) return
    const i = new Map()
    for (const t of e.masks) t && i.set(t.id, t)
    if (
      (null == (t = e.effects) ||
        t.forEach((e) => {
          if (e) {
            if (void 0 !== e.maskReferences && e.maskReferences.length > 0) {
              const t = []
              e.maskReferences.forEach((e) => {
                const r = e.id,
                  s = i.get(r)
                void 0 !== s && t.push(s)
              }),
                (e.maskReferences = t)
            }
            switch (e.type()) {
              case Oe.Fill:
                if (void 0 !== e.fillMask) {
                  const t = e.fillMask.id,
                    r = i.get(t)
                  void 0 !== r && (e.fillMask = r)
                }
                break
              case Oe.Stroke: {
                const t = e
                if (void 0 !== t.path) {
                  const e = t.path.id,
                    r = i.get(e)
                  void 0 !== r && (t.path = r)
                }
                break
              }
            }
          }
        }),
      e.type() === Re.Text)
    ) {
      const { pathOption: t } = e
      if (null == t ? void 0 : t.path) {
        const e = t.path.id,
          r = i.get(e)
        void 0 !== r && (t.path = r)
      }
    }
  },
  Rt = (e) => {
    switch (e) {
      case xe.Alpha:
      case xe.AlphaInverted:
        return !0
      default:
        return !1
    }
  }

function Pt(e, t, i) {
  switch (t) {
    case de.VectorCompositionBlock:
      i.compositions.push(
        ((e) => {
          const t = new Ne()
          return (t.id = e.readEncodedUint32()), ue(e, t, Et), Tt(t.layers), t
        })(e)
      )
      break
    case de.VideoCompositionBlock:
      i.compositions.push(
        ((e) => {
          const t = new ve()
          return (
            (t.id = e.readEncodedUint32()),
            (t.hasAlpha = e.readBoolean()),
            ue(
              e,
              {
                composition: t,
                hasAlpha: t.hasAlpha,
              },
              Ie
            ),
            t
          )
        })(e)
      )
  }
}
const At = (e) => {
    const t = Dt(e),
      { context: i } = t
    ue(t, i, Pt),
      (function (e) {
        if (!e || 0 === e.length) return
        const t = new Map()
        e.forEach((e) => {
          e && t.set(e.id, e)
        }),
          e.forEach((e) => {
            if (e && e.type() === le.Vector) {
              const i = e
              i.layers &&
                i.layers.length > 0 &&
                i.layers.forEach((e) => {
                  e.containingComposition = i
                  const r = e
                  if (r.type() === Re.PreCompose && r.composition) {
                    const e = t.get(r.composition.id)
                    e && (r.composition = e)
                  }
                })
            }
          })
      })(i.compositions)
    const r = i.releaseCompositions()
    return (
      ((e) => {
        let t = e.length > 0
        for (const i of e)
          if (!i || !i.verify()) {
            t = !1
            break
          }
        if (!t) throw new Error('Verify composition failed!')
      })(r),
      {
        compositions: r,
        tagLevel: i.tagLevel,
      }
    )
  },
  Dt = (e) => {
    if (e.length < 11) throw new Error('PAG file is invalid!')
    const t = e.readInt8(),
      i = e.readInt8(),
      r = e.readInt8()
    if (80 !== t || 65 !== i || 71 !== r) throw new Error('invalid PAG header!')
    return e.readInt8(), e.readUint32(), e.readInt8(), e.readBytes()
  }
class kt {
  constructor(e, t) {
    ;(this.tagLevel = 1),
      (this.compositions = []),
      (this.numLayers = 0),
      (this.scaledTimeRange = {
        start: 0,
        end: 0,
      }),
      (this.mainComposition = e[e.length - 1]),
      (this.scaledTimeRange.start = 0),
      (this.scaledTimeRange.end = this.mainComposition.duration),
      (this.compositions = e),
      (this.duration = this.mainComposition.duration),
      (this.implDuration = (1e3 * this.mainComposition.duration) / this.mainComposition.frameRate)
    for (const t of e)
      if (t.type() === le.Vector) for (const e of t.layers) e.type() !== Re.PreCompose && (this.numLayers += 1)
      else this.numLayers += 1
    this.tagLevel = t
  }
  static fromArrayBuffer(e) {
    if (!e || 0 === e.byteLength) throw new Error("Can't read empty array buffer!")
    const t = new Le(e, !0),
      { compositions: i, tagLevel: r } = At(t)
    return new kt(i, r)
  }
  getVideoSequence() {
    const e = this.mainComposition.type()
    return e === le.Video ? Ft(this.mainComposition) : e === le.Vector ? Vt(this.mainComposition) : void 0
  }
}
const Ft = (e) => {
    if (!e.sequences || 0 === e.sequences.length) throw new Error('PAGFile has no BMP video sequence!')
    return e.sequences[e.sequences.length - 1]
  },
  Vt = (e) => {
    const t = Ct(e)
    if (t.length > 1) throw new Error('PAGFile has more than one BMP video sequence!')
    if (t.length < 1) throw new Error('PAGFile has no BMP video sequence!')
    const i = t[0]
    return Ft(i)
  },
  Ct = (e) => {
    const t = []
    return (
      e.layers.forEach((e) => {
        if (e.type() !== Re.PreCompose) return
        const { composition: i } = e
        ;(null == i ? void 0 : i.type()) !== le.Video
          ? (null == i ? void 0 : i.type()) === le.Vector && t.push(...Ct(i))
          : t.push(i)
      }),
      t
    )
  }
class Lt extends he {
  constructor(e, t) {
    super(e, t, {
      renderingMode: O.WebGL,
    }),
      (this.frameData = void 0),
      (this.needGetFrame = !1),
      (this.flushBaseTime = Math.floor(1e3 / this.videoSequence.frameRate)),
      this.videoReader.start()
  }
  static init(e, t) {
    const i = new s(),
      r = kt.fromArrayBuffer(e)
    i.mark('decode')
    const a = new Lt(r, t)
    return (
      a.setDebugData({
        decodePAGFile: i.measure('', 'decode'),
      }),
      a
    )
  }
  async play() {
    this.playing ||
      ((this.playing = !0),
      await this.videoReader.start(),
      this.flushLoop(),
      0 === this.getProgress() && this.eventManager.emit(q.onAnimationStart),
      this.eventManager.emit(q.onAnimationPlay))
  }
  pause() {
    this.playing && (this.clearTimer(), (this.playing = !1), this.eventManager.emit(q.onAnimationPause))
  }
  stop() {
    this.clearTimer(),
      this.seekToStart(),
      this.clearRender(),
      (this.playing = !1),
      this.eventManager.emit(q.onAnimationCancel)
  }
  destroy() {
    this.clearTimer(), this.videoReader.destroy(), this.clearRender(), (this.canvas = null), (this.destroyed = !0)
  }
  updateSize() {}
  setProgress(e) {
    if (e < 0 || e > 1) throw new Error('progress must be between 0.0 and 1.0!')
    const t = Math.round(e * this.videoSequence.frameCount)
    if (this.currentFrame !== t)
      return t !== this.currentFrame + 1 && (this.needSeek = !0), (this.needGetFrame = !0), void (this.currentFrame = t)
    ;(this.needSeek = !1), (this.needGetFrame = !1)
  }
  async flushInternal() {
    const t = () => {
      const e = Date.now()
      this.draw(),
        this.setDebugData({
          draw: Date.now() - e,
        }),
        this.updateFPS(),
        this.eventManager.emit(q.onAnimationUpdate)
    }
    if (
      (this.needSeek &&
        ((this.needSeek = !1), await this.videoReader.seek((this.currentFrame / this.frameRate()) * 1e3)),
      this.needGetFrame)
    ) {
      this.needGetFrame = !1
      const i = Date.now()
      this.videoReader.getFrameData((r) => {
        ;(this.frameData = r),
          (this.currentFrame = r.id),
          this.setDebugData({
            getFrame: Date.now() - i,
          }),
          e &&
            (this.scale = {
              x: (16 * Math.ceil(this.frameData.width / 16)) / this.frameData.width,
              y: (16 * Math.ceil(this.frameData.height / 16)) / this.frameData.height,
            }),
          t(),
          this.currentFrame === this.videoSequence.frameCount - 1 && this.repeat()
      })
    } else t()
  }
  flushLoop() {
    return (
      (this.renderTimer = setInterval(async () => {
        ;(this.needGetFrame = !0), this.flushInternal()
      }, this.flushBaseTime)),
      Promise.resolve()
    )
  }
  detectWebGLContext() {
    return !0
  }
  createVideoReader(e) {
    const { videoReader: t, debugData: i } = I.create(e)
    return this.setDebugData(i), t
  }
  texImage2D() {
    this.gl.texImage2D(
      this.gl.TEXTURE_2D,
      0,
      this.gl.RGBA,
      this.frameData.width,
      this.frameData.height,
      0,
      this.gl.RGBA,
      this.gl.UNSIGNED_BYTE,
      new Uint8Array(this.frameData.data)
    )
  }
  repeat() {
    return 0 === this.repeatCount
      ? (this.clearTimer(),
        this.seekToStart(),
        (this.playing = !1),
        this.eventManager.emit('onAnimationEnd'),
        Promise.resolve(!1))
      : ((this.repeatCount -= 1), this.seekToStart(), this.eventManager.emit('onAnimationRepeat'), Promise.resolve(!0))
  }
  clearTimer() {
    this.renderTimer && (clearTimeout(this.renderTimer), (this.renderTimer = null)), this.videoReader.clearCallback()
  }
  async seekToStart() {
    this.videoReader.seek(0), (this.currentFrame = -1)
  }
}
export const PAGView = Lt
export const clearCache = () =>
  ((e) => {
    try {
      const t = i.readdirSync(e)
      return (
        t.length > 0 &&
          t.forEach((t) => {
            i.unlinkSync(`${e}${t}`)
          }),
        !0
      )
    } catch (e) {
      return console.error(e), !1
    }
  })(t)
export const types = N
